@causari/mcp-server 0.1.1

package/dist/chunk-7XWPOH6R.js

@@ -0,0 +1,4552 @@
+// ../../packages/ckg/dist/store.js
+var CKGStore = class {
+  events = /* @__PURE__ */ new Map();
+  links = /* @__PURE__ */ new Map();
+  insights = /* @__PURE__ */ new Map();
+  // Adjacency indexes for fast causal traversal.
+  // outgoing[A] = links where A is the cause; incoming[A] = links where A is the effect.
+  outgoing = /* @__PURE__ */ new Map();
+  incoming = /* @__PURE__ */ new Map();
+  constructor(seed10) {
+    if (seed10) {
+      seed10.events?.forEach((e) => this.addEvent(e));
+      seed10.causalLinks?.forEach((l) => this.addLink(l));
+      seed10.insights?.forEach((i) => this.addInsight(i));
+    }
+  }
+  addEvent(e) {
+    this.events.set(e.id, e);
+  }
+  addLink(l) {
+    if (!this.events.has(l.fromEvent) || !this.events.has(l.toEvent)) {
+      return;
+    }
+    this.links.set(l.id, l);
+    if (!this.outgoing.has(l.fromEvent))
+      this.outgoing.set(l.fromEvent, []);
+    this.outgoing.get(l.fromEvent).push(l);
+    if (!this.incoming.has(l.toEvent))
+      this.incoming.set(l.toEvent, []);
+    this.incoming.get(l.toEvent).push(l);
+  }
+  addInsight(i) {
+    this.insights.set(i.id, i);
+  }
+  getEvent(id) {
+    return this.events.get(id);
+  }
+  getLink(id) {
+    return this.links.get(id);
+  }
+  getInsight(id) {
+    return this.insights.get(id);
+  }
+  /**
+   * All outgoing causal links from a given event (this event as cause).
+   * Filtered by minConfidence if provided.
+   */
+  outgoingFrom(eventId, minConfidence = 0) {
+    const links = this.outgoing.get(eventId) ?? [];
+    return minConfidence > 0 ? links.filter((l) => l.confidence >= minConfidence) : links;
+  }
+  /**
+   * All incoming causal links into a given event (this event as effect).
+   */
+  incomingTo(eventId, minConfidence = 0) {
+    const links = this.incoming.get(eventId) ?? [];
+    return minConfidence > 0 ? links.filter((l) => l.confidence >= minConfidence) : links;
+  }
+  allEvents() {
+    return Array.from(this.events.values());
+  }
+  allLinks() {
+    return Array.from(this.links.values());
+  }
+  allInsights() {
+    return Array.from(this.insights.values());
+  }
+  stats(scope = "world") {
+    const events = this.allEvents().filter((e) => e.scope === scope);
+    const links = this.allLinks().filter((l) => l.scope === scope);
+    const insights = this.allInsights();
+    const domains = {};
+    for (const e of events) {
+      for (const d of e.domains) {
+        domains[d] = (domains[d] ?? 0) + 1;
+      }
+    }
+    return {
+      eventCount: events.length,
+      causalLinkCount: links.length,
+      insightCount: insights.length,
+      domains,
+      scope,
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+};
+
+// ../../packages/ckg/dist/seed/events.js
+var demoSource = {
+  type: "demo-seed",
+  reliability: 0.95,
+  citation: "Causari demo-v2.0.html curated baseline"
+};
+function ev(e) {
+  return { ...e, scope: "world", sources: [demoSource] };
+}
+var seedEvents = [
+  // ── Core historical chain ──────────────────────────────────────────────
+  ev({
+    id: "lang",
+    title: "Emergence of Language",
+    description: "The cognitive revolution that turned thought into syntax. Language became the first protocol for transmitting structured information across minds and generations, enabling symbolic worldviews and the social fabric of belief.",
+    yearNum: -7e4,
+    yearLabel: "70k BCE",
+    precision: "millennium",
+    domains: ["humanities", "culture", "systems"],
+    impactScore: 0.95,
+    tags: ["communication", "origin", "cognition", "protocol"]
+  }),
+  ev({
+    id: "write",
+    title: "Invention of Writing",
+    description: "Encoding knowledge into matter. Writing externalized memory beyond the human brain \u2014 the first storage layer of civilization, enabling cumulative culture across centuries.",
+    yearNum: -3500,
+    yearLabel: "3500 BCE",
+    precision: "century",
+    domains: ["humanities", "technology", "systems"],
+    impactScore: 0.92,
+    tags: ["storage", "knowledge", "memory", "cuneiform"]
+  }),
+  ev({
+    id: "alex",
+    title: "Library of Alexandria",
+    description: "Centralized data architecture v1.0. The peak of ancient curiosity \u2014 a deliberate attempt to aggregate global knowledge in one place. Foreshadowed both the promise and fragility of centralized information systems.",
+    yearNum: -331,
+    yearLabel: "331 BCE",
+    precision: "year",
+    domains: ["humanities", "systems"],
+    impactScore: 0.78,
+    tags: ["library", "knowledge", "centralization"],
+    wikidataId: "Q177260"
+  }),
+  ev({
+    id: "rome",
+    title: "Fall of the Roman Empire",
+    description: "Information flow disruption at civilization scale. The breakdown shows how complex coordination systems can collapse when their substrate (roads, administration, literacy) erodes \u2014 the dark ages were a system breakdown more than an absence.",
+    yearNum: 476,
+    yearLabel: "476 CE",
+    precision: "year",
+    domains: ["systems", "geopolitics", "humanities"],
+    impactScore: 0.82,
+    tags: ["collapse", "history", "system-failure"],
+    wikidataId: "Q40878"
+  }),
+  ev({
+    id: "printing",
+    title: "Gutenberg Printing Press",
+    description: "Mechanical replication broke the church/state monopoly on knowledge distribution. Mass-produced text democratized information, directly enabling the Reformation, Renaissance, and Scientific Revolution.",
+    yearNum: 1440,
+    yearLabel: "1440",
+    precision: "decade",
+    domains: ["technology", "humanities"],
+    impactScore: 0.94,
+    tags: ["technology", "distribution", "revolution", "broadcast"],
+    wikidataId: "Q11331"
+  }),
+  ev({
+    id: "rena",
+    title: "Renaissance",
+    description: "The kernel update of European civilization. Recovery of classical knowledge plus printed dissemination produced a step-change in scientific method, art, and humanist philosophy.",
+    yearNum: 1500,
+    yearLabel: "1500",
+    precision: "century",
+    domains: ["humanities", "science", "culture"],
+    impactScore: 0.88,
+    tags: ["rebirth", "science", "art", "humanism"],
+    wikidataId: "Q4692"
+  }),
+  ev({
+    id: "indus",
+    title: "Industrial Revolution",
+    description: "Energy transformation: chemical \u2192 mechanical \u2192 social. Power grid v1 reorganized human society around production, urbanization, and capital \u2014 and started the carbon curve that defines climate today.",
+    yearNum: 1800,
+    yearLabel: "1800",
+    precision: "decade",
+    domains: ["technology", "economy", "environment"],
+    impactScore: 0.96,
+    tags: ["technology", "energy", "revolution", "urbanization"],
+    wikidataId: "Q43332"
+  }),
+  // ── 1859→1953 scientific transition ───────────────────────────────────
+  ev({
+    id: "darwin_ev",
+    title: "Darwinian Evolution",
+    description: "Natural selection replaced creation theory. Reframed humanity as one species among many \u2014 a biological algorithm, not a designed peak.",
+    yearNum: 1859,
+    yearLabel: "1859",
+    precision: "year",
+    domains: ["science", "systems", "philosophy"],
+    impactScore: 0.85,
+    tags: ["evolution", "biology", "theory", "naturalism"],
+    wikidataId: "Q83337"
+  }),
+  ev({
+    id: "relativity",
+    title: "General Relativity",
+    description: "Spacetime is curved by mass. Einstein's theory dissolved Newton's absolute frame and laid the foundation for modern cosmology, GPS, and our understanding of gravity at scale.",
+    yearNum: 1915,
+    yearLabel: "1915",
+    precision: "year",
+    domains: ["science", "technology"],
+    impactScore: 0.86,
+    tags: ["physics", "science", "einstein", "spacetime"],
+    wikidataId: "Q11452"
+  }),
+  ev({
+    id: "turing_m",
+    title: "Turing Machine",
+    description: "Can a machine think? Turing's universal computation model \u2014 and the test that bears his name \u2014 set the agenda for computer science and artificial intelligence for the next 75 years.",
+    yearNum: 1950,
+    yearLabel: "1950",
+    precision: "year",
+    domains: ["technology", "science", "philosophy"],
+    impactScore: 0.88,
+    tags: ["computing", "AI", "theory", "turing"],
+    wikidataId: "Q163310"
+  }),
+  ev({
+    id: "dna_disc",
+    title: "DNA Double Helix",
+    description: "Watson and Crick decoded the structure of life's source code. Established that biology runs on a digital substrate \u2014 a discovery that converges with computing 50 years later in synthetic biology.",
+    yearNum: 1953,
+    yearLabel: "1953",
+    precision: "year",
+    domains: ["science", "systems", "health"],
+    impactScore: 0.9,
+    tags: ["biology", "code", "genetics", "helix"],
+    wikidataId: "Q7430"
+  }),
+  // ── 1969→2017 digital cluster ─────────────────────────────────────────
+  ev({
+    id: "internet",
+    title: "ARPANET / Internet",
+    description: "The first packet-switched network \u2014 a unified protocol that turned the planet into a single information substrate. Echoes the printing press at 100x scale and 1000x speed.",
+    yearNum: 1969,
+    yearLabel: "1969",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.96,
+    tags: ["network", "technology", "communication", "tcp-ip"],
+    wikidataId: "Q75"
+  }),
+  ev({
+    id: "web",
+    title: "World Wide Web",
+    description: "Tim Berners-Lee gave the internet a navigable surface. HTTP/HTML flattened information hierarchy and set the conditions for the platform economy.",
+    yearNum: 1991,
+    yearLabel: "1991",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.92,
+    tags: ["internet", "technology", "http", "hypertext"],
+    wikidataId: "Q466"
+  }),
+  ev({
+    id: "genome",
+    title: "Human Genome Project",
+    description: "Reading the complete genetic blueprint of Homo sapiens. Made personalized medicine possible and accelerated biotech by orders of magnitude.",
+    yearNum: 2003,
+    yearLabel: "2003",
+    precision: "year",
+    domains: ["science", "health"],
+    impactScore: 0.84,
+    tags: ["biology", "genetics", "code", "genome"],
+    wikidataId: "Q190977"
+  }),
+  ev({
+    id: "iphone",
+    title: "iPhone / Smartphone Era",
+    description: "The pocket computer became universal. Always-on connectivity restructured attention, work, and social life \u2014 and seeded the data economy that fuels modern AI.",
+    yearNum: 2007,
+    yearLabel: "2007",
+    precision: "year",
+    domains: ["technology", "culture", "economy"],
+    impactScore: 0.88,
+    tags: ["mobile", "technology", "device", "smartphone"],
+    wikidataId: "Q2766"
+  }),
+  ev({
+    id: "bitcoin",
+    title: "Bitcoin / Blockchain",
+    description: "The first decentralized ledger. Introduced trustless coordination \u2014 algorithm replacing institution \u2014 and demonstrated programmable scarcity.",
+    yearNum: 2009,
+    yearLabel: "2009",
+    precision: "year",
+    domains: ["technology", "economy", "systems"],
+    impactScore: 0.78,
+    tags: ["crypto", "technology", "decentralized", "blockchain"],
+    wikidataId: "Q131723"
+  }),
+  ev({
+    id: "transformer",
+    title: "Transformer Architecture",
+    description: "The 'Attention Is All You Need' paper \u2014 the architecture underlying GPT, Claude, and every modern LLM. Made language a first-class computational object.",
+    yearNum: 2017,
+    yearLabel: "2017",
+    precision: "year",
+    domains: ["technology", "science"],
+    impactScore: 0.93,
+    tags: ["AI", "deep-learning", "architecture", "attention", "llm"]
+  }),
+  // ── Present + speculative future anchors ──────────────────────────────
+  ev({
+    id: "ai",
+    title: "AI Era (Present)",
+    description: "Generative AI crosses from research to mass deployment. Self-referential intelligence: AI helps build AI, AI helps design biology, AI mediates most knowledge work.",
+    yearNum: 2026,
+    yearLabel: "2026",
+    precision: "year",
+    domains: ["technology", "science", "economy", "culture"],
+    impactScore: 0.97,
+    tags: ["ai", "present", "llm", "agent"]
+  }),
+  ev({
+    id: "mar",
+    title: "Multi-planetary Expansion",
+    description: "Speculative: humanity becomes a multi-planet species. Early Mars settlement and orbital habitats redistribute civilization across distributed nodes.",
+    yearNum: 2080,
+    yearLabel: "2080",
+    precision: "decade",
+    domains: ["technology", "systems"],
+    impactScore: 0.7,
+    tags: ["space", "future", "expansion", "mars"],
+    forecastConfidence: 0.4,
+    forecastReasoning: "Extrapolation from current space industry growth + cost curves"
+  }),
+  ev({
+    id: "omega",
+    title: "Omega (Heat Death)",
+    description: "Cosmological end state. The eventual silence of the universe \u2014 the outer bound of all possible timelines.",
+    yearNum: 1e100,
+    yearLabel: "\u221E",
+    precision: "millennium",
+    domains: ["science", "philosophy"],
+    impactScore: 0.5,
+    tags: ["end", "future", "eternal", "cosmology"]
+  }),
+  // ── Forecast nodes (UC4) ──────────────────────────────────────────────
+  ev({
+    id: "forecast_quantum",
+    title: "Practical Quantum Computing",
+    description: "Quantum computers cross the threshold of practical advantage for specific problem classes (cryptography, simulation, optimization).",
+    yearNum: 2032,
+    yearLabel: "2032",
+    precision: "year",
+    domains: ["technology", "science"],
+    impactScore: 0.75,
+    tags: ["quantum", "forecast", "computing"],
+    forecastConfidence: 0.78,
+    forecastReasoning: "Computer Science \u2192 Moore's Law extrapolation + current quantum hardware progress"
+  }),
+  ev({
+    id: "forecast_neural",
+    title: "Neural Interfaces (Mainstream)",
+    description: "Brain-computer interfaces transition from medical-only to consumer-grade for memory augmentation and direct AI interaction.",
+    yearNum: 2030,
+    yearLabel: "2030",
+    precision: "year",
+    domains: ["technology", "science", "health"],
+    impactScore: 0.7,
+    tags: ["neural", "forecast", "BCI", "augmentation"],
+    forecastConfidence: 0.65,
+    forecastReasoning: "Brain Science + AI integration + current Neuralink/synchron progress"
+  }),
+  ev({
+    id: "forecast_mars",
+    title: "First Mars Settlement",
+    description: "Permanent human habitation on Mars (>50 people, >1 year). Humanity becomes biologically multi-planetary.",
+    yearNum: 2042,
+    yearLabel: "2042",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.72,
+    tags: ["space", "forecast", "mars", "colonization"],
+    forecastConfidence: 0.62,
+    forecastReasoning: "SpaceX trajectory + cost curves + government program funding"
+  }),
+  ev({
+    id: "forecast_renewable",
+    title: "Global Renewable Dominance",
+    description: "Renewable energy sources exceed 50% of global generation, with distributed storage solving intermittency.",
+    yearNum: 2031,
+    yearLabel: "2031",
+    precision: "year",
+    domains: ["technology", "environment", "systems"],
+    impactScore: 0.85,
+    tags: ["energy", "forecast", "renewable", "climate"],
+    forecastConfidence: 0.8,
+    forecastReasoning: "Energy revolution trend + LCOE curves + storage progress"
+  }),
+  ev({
+    id: "forecast_agi",
+    title: "AGI Threshold",
+    description: "Multi-purpose artificial intelligence reaches or exceeds human cognitive performance across most domains.",
+    yearNum: 2040,
+    yearLabel: "2040",
+    precision: "year",
+    domains: ["technology", "science", "philosophy"],
+    impactScore: 0.95,
+    tags: ["agi", "forecast", "ai", "general-intelligence"],
+    forecastConfidence: 0.55,
+    forecastReasoning: "Current AI scaling laws + algorithmic progress + compute trajectory"
+  }),
+  ev({
+    id: "forecast_longevity",
+    title: "Longevity Tech (Mainstream)",
+    description: "Aging-control therapies extend healthspan by 10-20 years for treated populations.",
+    yearNum: 2035,
+    yearLabel: "2035",
+    precision: "year",
+    domains: ["health", "science"],
+    impactScore: 0.75,
+    tags: ["longevity", "forecast", "aging", "biology"],
+    forecastConfidence: 0.7,
+    forecastReasoning: "Biology + AI convergence + senolytics clinical trials"
+  }),
+  ev({
+    id: "forecast_synthesis",
+    title: "Synthetic Biology (Designer Organisms)",
+    description: "Engineered organisms become routine for industrial chemicals, food production, and disease eradication.",
+    yearNum: 2029,
+    yearLabel: "2029",
+    precision: "year",
+    domains: ["science", "health", "environment"],
+    impactScore: 0.78,
+    tags: ["synthetic-biology", "forecast", "genetic-engineering"],
+    forecastConfidence: 0.75,
+    forecastReasoning: "Biotech advancement + CRISPR + AI-designed proteins"
+  }),
+  ev({
+    id: "forecast_fusion",
+    title: "Fusion Power (Commercial)",
+    description: "First commercially-operating fusion power plants delivering net energy at competitive costs.",
+    yearNum: 2036,
+    yearLabel: "2036",
+    precision: "year",
+    domains: ["technology", "science", "environment"],
+    impactScore: 0.83,
+    tags: ["fusion", "forecast", "energy", "physics"],
+    forecastConfidence: 0.68,
+    forecastReasoning: "Physics progress + private fusion company milestones (Helion, CFS)"
+  }),
+  ev({
+    id: "forecast_climate",
+    title: "Climate Restoration Programs",
+    description: "Coordinated planetary-scale carbon capture + ecosystem restoration begins to reverse atmospheric CO2 trajectory.",
+    yearNum: 2030,
+    yearLabel: "2030",
+    precision: "year",
+    domains: ["environment", "systems", "geopolitics"],
+    impactScore: 0.88,
+    tags: ["climate", "forecast", "restoration", "carbon"],
+    forecastConfidence: 0.72,
+    forecastReasoning: "Environmental science + international policy + tech maturity"
+  }),
+  ev({
+    id: "forecast_distributed",
+    title: "Decentralized Governance",
+    description: "Blockchain-based voting and DAO structures move from niche to standard at municipal/national level.",
+    yearNum: 2042,
+    yearLabel: "2042",
+    precision: "year",
+    domains: ["systems", "geopolitics", "technology"],
+    impactScore: 0.6,
+    tags: ["governance", "forecast", "decentralized", "dao"],
+    forecastConfidence: 0.48,
+    forecastReasoning: "Bitcoin + internet evolution + crypto governance experiments"
+  }),
+  ev({
+    id: "forecast_consciousness",
+    title: "Mind Upload (Speculative)",
+    description: "First credible attempts at digital consciousness transfer. Definition and verification highly contested.",
+    yearNum: 2060,
+    yearLabel: "2060",
+    precision: "decade",
+    domains: ["science", "philosophy", "technology"],
+    impactScore: 0.8,
+    tags: ["consciousness", "forecast", "mind-upload", "speculative"],
+    forecastConfidence: 0.3,
+    forecastReasoning: "Neuroscience + AI + neural interface convergence (high uncertainty)"
+  }),
+  ev({
+    id: "forecast_language",
+    title: "Universal Translation",
+    description: "Real-time accurate translation across all major languages becomes free, ubiquitous infrastructure.",
+    yearNum: 2038,
+    yearLabel: "2038",
+    precision: "year",
+    domains: ["technology", "humanities"],
+    impactScore: 0.68,
+    tags: ["translation", "forecast", "language", "nlp"],
+    forecastConfidence: 0.7,
+    forecastReasoning: "NLP advancement + transformer architecture maturity"
+  }),
+  ev({
+    id: "forecast_space_trade",
+    title: "Interplanetary Commerce",
+    description: "Regular cargo trade routes between Earth and Mars/orbital settlements operate commercially.",
+    yearNum: 2048,
+    yearLabel: "2048",
+    precision: "decade",
+    domains: ["economy", "technology"],
+    impactScore: 0.6,
+    tags: ["space-commerce", "forecast", "logistics"],
+    forecastConfidence: 0.35,
+    forecastReasoning: "Mars settlement + space economy maturity (depends on forecast_mars)"
+  }),
+  ev({
+    id: "forecast_quantum_net",
+    title: "Quantum Internet",
+    description: "Quantum-secured global network operates between major data centers. Unhackable communication baseline.",
+    yearNum: 2034,
+    yearLabel: "2034",
+    precision: "year",
+    domains: ["technology", "science"],
+    impactScore: 0.7,
+    tags: ["quantum-internet", "forecast", "security", "qkd"],
+    forecastConfidence: 0.58,
+    forecastReasoning: "Quantum computing + cryptography progress"
+  }),
+  ev({
+    id: "forecast_bio_ai",
+    title: "Bio-AI Convergence",
+    description: "Hybrid biological-digital organisms enter agriculture, medicine, and computing. Substrate boundary blurs.",
+    yearNum: 2033,
+    yearLabel: "2033",
+    precision: "year",
+    domains: ["science", "technology", "health"],
+    impactScore: 0.78,
+    tags: ["bio-ai", "forecast", "hybrid", "convergence"],
+    forecastConfidence: 0.64,
+    forecastReasoning: "Biotech + AI convergence + CRISPR + brain-organoid research"
+  })
+];
+
+// ../../packages/ckg/dist/seed/links.js
+var seed = (fromEvent, toEvent, rel, evidence, confidence) => ({
+  id: `${fromEvent}--${rel}-->${toEvent}`,
+  fromEvent,
+  toEvent,
+  relationship: rel,
+  confidence: confidence ?? (rel === "caused" ? 0.9 : 0.8),
+  evidence,
+  sources: [{ type: "demo-seed", reliability: 0.9, citation: "Causari curated baseline" }],
+  contributedBy: "system",
+  validated: true,
+  scope: "world"
+});
+var seedLinks = [
+  // Foundation chain
+  seed("lang", "write", "enabled", "Spoken language created the cognitive scaffold (syntax, abstraction) that writing systems formalize. Without language structure, symbolic encoding has nothing to encode."),
+  seed("write", "alex", "enabled", "Durable written records made centralized libraries possible. Alexandria aggregated what writing had begun preserving across centuries."),
+  seed("alex", "printing", "enabled", "The library tradition of preserving and copying texts established the cultural infrastructure that the printing press would later automate at scale."),
+  seed("printing", "rena", "caused", "Mechanical reproduction broke clerical knowledge monopoly within a single generation. Cheap books \u2192 wider literacy \u2192 demand for classical texts \u2192 Renaissance.", 0.92),
+  // Scientific chain
+  seed("rena", "indus", "enabled", "Renaissance scientific method (empirical observation, mathematical modeling) provided the epistemological substrate for systematic engineering."),
+  seed("indus", "darwin_ev", "enabled", "Industrial wealth funded scientific expeditions (HMS Beagle); industrial-era geology established deep time, the prerequisite for evolutionary thinking."),
+  seed("darwin_ev", "relativity", "enabled", "Evolutionary thinking normalized the idea that fundamental categories (species, time, frame of reference) are not absolute. This conceptual flexibility primed physics for relativity."),
+  seed("relativity", "turing_m", "enabled", "Hilbert's formalist program (which Turing addressed) was a response to crises in mathematical foundations that included relativity's reframing of geometry. Same intellectual climate."),
+  // Code & biology merge
+  seed("turing_m", "dna_disc", "enabled", `Turing's information-theoretic framing seeded the metaphor of biological "code". The structural search for DNA was guided by the question: what is the substrate of biological information?`),
+  seed("dna_disc", "relativity", "enabled", "DNA as discrete information substrate strengthened the broader 20th-c shift toward discrete/quantized models of nature, reinforcing relativity's framework.", 0.5),
+  // Digital chain
+  seed("dna_disc", "internet", "enabled", "Information theory developed in molecular biology (Shannon, Wiener era) directly fed the network protocols that became ARPANET."),
+  seed("internet", "web", "enabled", "TCP/IP made the WWW protocol layer possible. The web is an application built on the internet; not the same thing.", 0.95),
+  seed("web", "iphone", "enabled", "A mobile device only makes sense if there is a content layer to consume. The web at scale (2007) created the demand for ubiquitous mobile access."),
+  // Genome understanding
+  seed("web", "genome", "enabled", "Distributed genome sequencing required cheap global coordination \u2014 bandwidth and shared databases that the web provided."),
+  seed("genome", "bitcoin", "enabled", "Decoding decentralized biological systems (no central planner; emergent behavior from rules) influenced the conceptual lineage that produced cryptocurrency.", 0.55),
+  // AI chain
+  seed("turing_m", "transformer", "enabled", "Computational substrate for all neural architectures traces to Turing-complete machines."),
+  seed("dna_disc", "transformer", "enabled", 'Neural networks were inspired by biological neurons; the explicit "neural network" framing depends on understanding biological information processing.', 0.7),
+  seed("iphone", "transformer", "enabled", "Mobile + web at scale generated the training data corpus and the GPU economic incentive that made transformer-scale training viable."),
+  seed("transformer", "ai", "caused", `Transformer architecture is the direct technical substrate of GPT, Claude, Gemini. Without 2017's "Attention Is All You Need", current LLMs do not exist.`, 0.95),
+  // Future
+  seed("ai", "mar", "enabled", "AI-driven robotics, materials science, and life-support engineering are prerequisites for cost-feasible Mars settlement.", 0.6),
+  seed("ai", "internet", "enabled", "Feedback loop: AI systems both consume and reshape internet infrastructure (search, recommendation, content generation).", 0.7),
+  // Cross-cutting feedbacks
+  seed("internet", "darwin_ev", "enabled", "Online publication of genomic data and computational evolution simulations expanded what evolutionary biology can do \u2014 feedback from later technology to earlier theory.", 0.5),
+  seed("printing", "indus", "enabled", "Technical manuals, patents, and scientific journals \u2014 all printing-press artifacts \u2014 were the knowledge distribution layer of the industrial revolution."),
+  seed("rena", "darwin_ev", "enabled", "Renaissance humanism placed humans within nature rather than above it. This philosophical reframing was the long arc that made evolution thinkable."),
+  seed("bitcoin", "ai", "enabled", "Decentralized consensus mechanisms inform multi-agent AI architectures and distributed training. Conceptual cross-pollination.", 0.55),
+  // Forecast → Forecast dependencies
+  seed("forecast_synthesis", "forecast_bio_ai", "enabled", "Synthetic biology provides the biological half of the bio-AI fusion equation."),
+  seed("forecast_quantum", "forecast_quantum_net", "enabled", "Quantum compute primitives are required to implement quantum-secured network protocols at scale."),
+  seed("forecast_renewable", "forecast_climate", "enabled", "Decarbonized energy grid is the largest single lever for atmospheric carbon trajectory reversal."),
+  seed("forecast_neural", "forecast_consciousness", "enabled", "Neural interfaces are the read/write hardware that any consciousness-transfer attempt would require."),
+  seed("forecast_agi", "forecast_distributed", "enabled", "AGI-mediated coordination could make decentralized governance practical at scale that humans alone cannot manage."),
+  seed("forecast_mars", "forecast_space_trade", "enabled", "Permanent Mars population creates the demand-side and supply-side endpoints for interplanetary trade."),
+  seed("forecast_quantum", "forecast_agi", "enabled", "Quantum-accelerated training could shorten AGI timelines by orders of magnitude on certain optimization problems.", 0.6),
+  seed("forecast_fusion", "forecast_renewable", "enabled", "Fusion provides the high-density baseload that complements intermittent renewables, completing the energy transition."),
+  seed("forecast_longevity", "forecast_consciousness", "enabled", "Longevity tech extends biological substrate; consciousness-transfer extends substrate beyond biology. Same problem space.", 0.6),
+  seed("forecast_language", "forecast_distributed", "enabled", "Universal translation removes the largest friction in cross-border governance coordination."),
+  seed("forecast_bio_ai", "forecast_agi", "enabled", "Biological substrates may contribute novel computational primitives toward AGI thresholds.", 0.5)
+];
+
+// ../../packages/ckg/dist/seed/insights.js
+var seedInsights = [
+  {
+    id: "pattern--info-democratization",
+    pattern: "Information Democratization Cycle",
+    description: "When a new medium dramatically lowers the cost of distributing knowledge, an institutional monopoly breaks within ~50 years. Pattern: writing \u2192 priesthood breaks; printing \u2192 clergy/state breaks; internet \u2192 mass media breaks; LLMs \u2192 expert credential systems break.",
+    instances: [
+      "lang--enabled-->write",
+      "write--enabled-->alex",
+      "printing--caused-->rena",
+      "internet--enabled-->web",
+      "transformer--caused-->ai"
+    ],
+    predictiveValue: 0.85,
+    domains: ["humanities", "technology", "systems"],
+    contributedBy: "system"
+  },
+  {
+    id: "pattern--substrate-substitution",
+    pattern: "Substrate Substitution",
+    description: "A capability historically running on substrate A migrates to substrate B once B becomes cheaper or more flexible. Mechanical \u2192 electrical (1900s); analog \u2192 digital (1970s); silicon \u2192 quantum (forecast). The migration creates discontinuities in adjacent industries.",
+    instances: [
+      "indus--enabled-->darwin_ev",
+      "turing_m--enabled-->transformer",
+      "forecast_quantum--enabled-->forecast_quantum_net"
+    ],
+    predictiveValue: 0.78,
+    domains: ["technology", "science"],
+    contributedBy: "system"
+  },
+  {
+    id: "pattern--coordination-scale-jump",
+    pattern: "Coordination Scale Jump",
+    description: "Each new communication infrastructure enables a step-change in social organization scale. Writing \u2192 cities. Printing \u2192 nations. Internet \u2192 platforms. Universal translation \u2192 ?. Pattern: ~3-4 orders of magnitude per cycle.",
+    instances: [
+      "write--enabled-->alex",
+      "printing--enabled-->indus",
+      "internet--enabled-->web",
+      "forecast_language--enabled-->forecast_distributed"
+    ],
+    predictiveValue: 0.72,
+    domains: ["systems", "geopolitics", "humanities"],
+    contributedBy: "system"
+  },
+  {
+    id: "pattern--information-as-physics",
+    pattern: "Information as Physical Substrate",
+    description: `Across the 20th century, information progressively moves from "abstract" to "physical": Shannon's information theory, DNA as code, Landauer's principle, quantum information. The boundary between bits and matter dissolves.`,
+    instances: [
+      "turing_m--enabled-->dna_disc",
+      "dna_disc--enabled-->internet",
+      "forecast_synthesis--enabled-->forecast_bio_ai"
+    ],
+    predictiveValue: 0.68,
+    domains: ["science", "technology"],
+    contributedBy: "system"
+  },
+  {
+    id: "pattern--abstraction-layer-migration",
+    pattern: "Abstraction Layer Migration",
+    description: "Computing advances by adding abstraction layers that hide complexity. Assembly \u2192 C \u2192 Python \u2192 LLM prompts. Each layer sacrifices some control for dramatically wider accessibility. The new layer never fully replaces the old \u2014 it sits on top, and experts still drop down when needed.",
+    instances: [
+      "fortran--enabled-->c_language",
+      "c_language--enabled-->python",
+      "c_language--enabled-->java",
+      "javascript--caused-->typescript",
+      "docker--caused-->kubernetes",
+      "transformer--caused-->ai"
+    ],
+    predictiveValue: 0.82,
+    domains: ["technology"],
+    contributedBy: "system"
+  },
+  {
+    id: "pattern--standardization-cycle",
+    pattern: "Standardization Cycle",
+    description: 'Technology follows a boom \u2192 fragmentation \u2192 standard \u2192 new boom cycle. Networking: many protocols \u2192 TCP/IP wins \u2192 web boom. Databases: many models \u2192 SQL standard \u2192 NoSQL reaction \u2192 NewSQL synthesis. Containers: many runtimes \u2192 OCI standard \u2192 K8s orchestration. The standard that wins is usually "good enough" technically but has the strongest ecosystem.',
+    instances: [
+      "tcp_ip_standard--enabled-->web",
+      "relational_db--caused-->postgresql",
+      "relational_db--enabled-->nosql_movement",
+      "docker--caused-->kubernetes",
+      "rest_api--enabled-->graphql"
+    ],
+    predictiveValue: 0.78,
+    domains: ["technology", "systems"],
+    contributedBy: "system"
+  },
+  {
+    id: "pattern--open-vs-proprietary-substrate",
+    pattern: "Open vs Proprietary Substrate",
+    description: "When a technology layer becomes infrastructure, open implementations eventually dominate. Unix/proprietary \u2192 Linux/open. IE/proprietary \u2192 Chrome/open-source. AWS/proprietary \u2192 K8s/open orchestration. The pattern: proprietary wins early (resources, polish), open wins long-term (ecosystem, trust, vendor independence).",
+    instances: [
+      "gnu_project--enabled-->linux",
+      "unix--inspired-->linux",
+      "linux--enabled-->docker",
+      "linux--enabled-->aws",
+      "git--caused-->github"
+    ],
+    predictiveValue: 0.75,
+    domains: ["technology", "economy", "systems"],
+    contributedBy: "system"
+  },
+  {
+    id: "pattern--prerequisite-cascade",
+    pattern: "Prerequisite Cascade in Future Tech",
+    description: "Forecasted breakthroughs cluster: each enables 2-3 downstream forecasts. Quantum compute enables both quantum internet and accelerated AGI. Mars settlement enables space commerce. This means timeline confidence in node N requires confidence in all upstream nodes \u2014 uncertainty compounds.",
+    instances: [
+      "forecast_quantum--enabled-->forecast_agi",
+      "forecast_quantum--enabled-->forecast_quantum_net",
+      "forecast_mars--enabled-->forecast_space_trade",
+      "forecast_agi--enabled-->forecast_distributed"
+    ],
+    predictiveValue: 0.6,
+    domains: ["technology", "systems"],
+    contributedBy: "system"
+  }
+];
+
+// ../../packages/ckg/dist/seed/events-ai-history.js
+var demoSource2 = {
+  type: "demo-seed",
+  reliability: 0.95,
+  citation: "Causari curated baseline \u2014 AI history extension"
+};
+function ev2(e) {
+  return { ...e, scope: "world", sources: [demoSource2] };
+}
+var aiHistoryEvents = [
+  ev2({
+    id: "mcculloch_pitts",
+    title: "McCulloch\u2013Pitts Neuron",
+    description: "First formal model of an artificial neuron \u2014 Warren McCulloch & Walter Pitts showed binary threshold logic could compute any Turing-complete function. The conceptual ancestor of every neural network that followed.",
+    yearNum: 1943,
+    yearLabel: "1943",
+    precision: "year",
+    domains: ["science", "technology"],
+    impactScore: 0.78,
+    tags: ["AI", "neuron", "theory", "foundational"],
+    wikidataId: "Q3140412"
+  }),
+  ev2({
+    id: "dartmouth_conf",
+    title: "Dartmouth Conference",
+    description: 'The summer workshop that named the field. McCarthy, Minsky, Shannon, Rochester convened to study "every aspect of learning or any other feature of intelligence" \u2014 the founding act of AI as a discipline.',
+    yearNum: 1956,
+    yearLabel: "1956",
+    precision: "year",
+    domains: ["science", "humanities"],
+    impactScore: 0.82,
+    tags: ["AI", "founding", "history", "discipline"],
+    wikidataId: "Q1141135"
+  }),
+  ev2({
+    id: "perceptron",
+    title: "Perceptron",
+    description: "Frank Rosenblatt's learning machine \u2014 first algorithm that could update connection weights from examples. Demonstrated machine learning was possible; oversold by the press as the dawn of thinking machines.",
+    yearNum: 1958,
+    yearLabel: "1958",
+    precision: "year",
+    domains: ["technology", "science"],
+    impactScore: 0.74,
+    tags: ["AI", "learning", "connectionism", "rosenblatt"],
+    wikidataId: "Q690207"
+  }),
+  ev2({
+    id: "ai_winter_1",
+    title: "First AI Winter",
+    description: "The Lighthill Report and Minsky & Papert's Perceptrons critique collapsed neural net research. UK and US funding evaporated; symbolic AI dominated for a decade. A cautionary tale about how overpromising kills fields.",
+    yearNum: 1974,
+    yearLabel: "1974",
+    precision: "year",
+    domains: ["systems", "economy"],
+    impactScore: 0.55,
+    tags: ["AI", "winter", "funding", "history"],
+    wikidataId: "Q335474"
+  }),
+  ev2({
+    id: "backprop",
+    title: "Backpropagation Popularised",
+    description: "Rumelhart, Hinton & Williams' paper made gradient descent through multi-layer networks practical. Re-ignited connectionism by solving the credit-assignment problem that had stalled perceptrons for 17 years.",
+    yearNum: 1986,
+    yearLabel: "1986",
+    precision: "year",
+    domains: ["science", "technology"],
+    impactScore: 0.83,
+    tags: ["AI", "deep-learning", "algorithm", "gradient"],
+    wikidataId: "Q798503"
+  }),
+  ev2({
+    id: "deep_blue",
+    title: "Deep Blue beats Kasparov",
+    description: `IBM's chess machine defeated the reigning world champion \u2014 the first symbolic landmark that a "creative" intellectual game could fall to brute search + handcrafted evaluation. Shifted public intuition about what machines could do.`,
+    yearNum: 1997,
+    yearLabel: "1997",
+    precision: "year",
+    domains: ["technology", "culture"],
+    impactScore: 0.7,
+    tags: ["AI", "chess", "milestone", "search"],
+    wikidataId: "Q102371"
+  }),
+  ev2({
+    id: "imagenet",
+    title: "ImageNet Released",
+    description: "Fei-Fei Li's 14M-image labeled dataset. The first time the AI community had enough data to actually train the deep nets the theory had been promising. Data became the new oil.",
+    yearNum: 2009,
+    yearLabel: "2009",
+    precision: "year",
+    domains: ["technology", "science"],
+    impactScore: 0.84,
+    tags: ["AI", "dataset", "computer-vision", "benchmark"],
+    wikidataId: "Q19829071"
+  }),
+  ev2({
+    id: "alexnet",
+    title: "AlexNet",
+    description: "Krizhevsky, Sutskever & Hinton's CNN crushed ImageNet 2012 by 10+ points. Deep learning's coming-out moment \u2014 convinced the field that GPUs + scale + backprop actually worked on real problems.",
+    yearNum: 2012,
+    yearLabel: "2012",
+    precision: "year",
+    domains: ["technology", "science"],
+    impactScore: 0.9,
+    tags: ["AI", "deep-learning", "computer-vision", "gpu"],
+    wikidataId: "Q24729090"
+  }),
+  ev2({
+    id: "alphago",
+    title: "AlphaGo defeats Lee Sedol",
+    description: "DeepMind's Go-playing system beat the 18-time world champion 4-1. Go's branching factor was supposed to be 10 years away; AlphaGo collapsed the timeline using deep RL + Monte Carlo tree search.",
+    yearNum: 2016,
+    yearLabel: "2016",
+    precision: "year",
+    domains: ["technology", "culture"],
+    impactScore: 0.82,
+    tags: ["AI", "reinforcement-learning", "go", "deepmind"],
+    wikidataId: "Q20708099"
+  }),
+  ev2({
+    id: "bert",
+    title: "BERT",
+    description: "Google's bidirectional transformer encoder. State-of-the-art on 11 NLP tasks the day it was released; defined the pre-train-then-fine-tune paradigm that still dominates production NLP.",
+    yearNum: 2018,
+    yearLabel: "2018",
+    precision: "year",
+    domains: ["technology", "science"],
+    impactScore: 0.8,
+    tags: ["AI", "nlp", "transformer", "google"],
+    wikidataId: "Q56624948"
+  }),
+  ev2({
+    id: "gpt2",
+    title: "GPT-2",
+    description: "OpenAI's 1.5B-parameter autoregressive model. Famously held back from full release over misuse concerns \u2014 first time an AI org publicly worried in advance about its own model's capability.",
+    yearNum: 2019,
+    yearLabel: "2019",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.75,
+    tags: ["AI", "llm", "gpt", "openai"],
+    wikidataId: "Q94531571"
+  }),
+  ev2({
+    id: "gpt3",
+    title: "GPT-3",
+    description: 'The 175B-parameter scale jump that made "prompt engineering" a real skill. Demonstrated emergent few-shot learning \u2014 capabilities that did not exist at smaller scale appeared past a threshold.',
+    yearNum: 2020,
+    yearLabel: "2020",
+    precision: "year",
+    domains: ["technology", "economy"],
+    impactScore: 0.88,
+    tags: ["AI", "llm", "gpt", "scaling", "emergence"],
+    wikidataId: "Q95726734"
+  }),
+  ev2({
+    id: "alphafold2",
+    title: "AlphaFold 2",
+    description: "DeepMind solved the 50-year-old protein-folding problem at CASP14 \u2014 predicting 3D structures from amino acid sequences at near-experimental accuracy. Opened structural biology to anyone with an internet connection.",
+    yearNum: 2020,
+    yearLabel: "2020",
+    precision: "year",
+    domains: ["science", "health"],
+    impactScore: 0.86,
+    tags: ["AI", "biology", "protein", "deepmind"],
+    wikidataId: "Q103862730"
+  }),
+  ev2({
+    id: "dalle",
+    title: "DALL\xB7E",
+    description: "OpenAI's text-to-image model. First widely-seen demonstration that diffusion-style generation could produce photorealistic novel imagery from natural language \u2014 kicked off the generative art era.",
+    yearNum: 2021,
+    yearLabel: "2021",
+    precision: "year",
+    domains: ["technology", "culture"],
+    impactScore: 0.76,
+    tags: ["AI", "generative", "image", "multimodal"],
+    wikidataId: "Q105509175"
+  }),
+  ev2({
+    id: "chatgpt",
+    title: "ChatGPT",
+    description: 'GPT-3.5 wrapped in a conversational UI + RLHF \u2014 1M users in 5 days, 100M in 2 months. The product moment AI crossed from research demo to mass consumer tool. Same day, AI moved from "interesting" to "strategic" for every company.',
+    yearNum: 2022,
+    yearLabel: "2022",
+    precision: "year",
+    domains: ["technology", "economy", "culture"],
+    impactScore: 0.94,
+    tags: ["AI", "llm", "chatbot", "rlhf", "consumer"],
+    wikidataId: "Q115564437"
+  })
+];
+
+// ../../packages/ckg/dist/seed/links-ai-history.js
+var seed2 = (fromEvent, toEvent, rel, evidence, confidence) => ({
+  id: `${fromEvent}--${rel}-->${toEvent}`,
+  fromEvent,
+  toEvent,
+  relationship: rel,
+  confidence: confidence ?? (rel === "caused" ? 0.9 : 0.8),
+  evidence,
+  sources: [{ type: "demo-seed", reliability: 0.9, citation: "Causari curated baseline" }],
+  contributedBy: "system",
+  validated: true,
+  scope: "world"
+});
+var aiHistoryLinks = [
+  // ── Foundations 1943 → 1986 ──────────────────────────────────────────
+  seed2("turing_m", "mcculloch_pitts", "enabled", "Turing's computability framework provided the formal substrate for McCulloch & Pitts to ask whether neurons themselves could be Turing-complete."),
+  seed2("mcculloch_pitts", "dartmouth_conf", "enabled", "A formal model of the neuron made artificial intelligence credible as a research programme \u2014 Dartmouth could only happen after the foundational mathematics existed."),
+  seed2("dartmouth_conf", "perceptron", "enabled", "The Dartmouth workshop established the AI research community; Rosenblatt built the perceptron two years later inside that emerging field."),
+  seed2("perceptron", "ai_winter_1", "caused", `Minsky & Papert's 1969 "Perceptrons" book proved the single-layer perceptron could not learn XOR \u2014 combined with public overhype, this triggered the funding collapse that became the first AI winter.`, 0.85),
+  seed2("ai_winter_1", "backprop", "enabled", "The winter forced researchers to address connectionism's core flaw: how to train deeper networks. Rumelhart-Hinton-Williams' 1986 backprop paper was the answer the field had been waiting 12 years to publish."),
+  // ── Compute + data preconditions ─────────────────────────────────────
+  seed2("backprop", "alexnet", "enabled", "Backpropagation made multi-layer training mathematically tractable; AlexNet showed it scaled to deep CNNs on GPUs. Same algorithm, 26 years later, finally on hardware that could run it."),
+  seed2("imagenet", "alexnet", "caused", "AlexNet was specifically trained on and submitted to the ImageNet 2012 challenge \u2014 without the labeled dataset there was no benchmark to win and no signal that depth mattered.", 0.95),
+  // ── Deep learning era branches ───────────────────────────────────────
+  seed2("alexnet", "alphago", "enabled", "AlexNet validated deep CNNs as state-of-the-art perception; AlphaGo's policy and value networks reused the same architecture family to score Go board positions."),
+  seed2("alexnet", "transformer", "enabled", "AlexNet established that scale + GPU compute + deep architectures beat hand-designed features. The transformer paper assumed that lesson and went bigger on attention rather than convolution."),
+  // ── Transformer cascade ─────────────────────────────────────────────
+  seed2("transformer", "bert", "caused", "BERT is a transformer encoder. Google's team applied the 2017 architecture to bidirectional pre-training and produced state-of-the-art NLP within a year.", 0.95),
+  seed2("transformer", "gpt2", "caused", "GPT-2 is a transformer decoder scaled to 1.5B params. The architectural choice is direct; the contribution is scale + the discovery that autoregressive pre-training transfers broadly.", 0.95),
+  seed2("gpt2", "gpt3", "enabled", "GPT-2 demonstrated that scaling helped without architectural change; GPT-3 took the same recipe to 175B and unlocked emergent few-shot learning."),
+  seed2("gpt3", "chatgpt", "enabled", "ChatGPT is GPT-3.5 + instruction tuning + RLHF + a chat UI. The base capability had to exist before product packaging could turn it into a consumer phenomenon."),
+  // ── Bridges into existing graph ──────────────────────────────────────
+  seed2("chatgpt", "ai", "caused", 'ChatGPT was the inflection point where generative AI crossed from research demo to mass deployment. The "AI Era" node represents the world post-November 2022.', 0.92),
+  seed2("alphafold2", "forecast_synthesis", "enabled", "AlphaFold 2 made protein structure prediction routine; synthetic biology design pipelines now assume structural prediction is free, accelerating the path to engineered organisms.")
+];
+
+// ../../packages/ckg/dist/seed/events-computing.js
+var src = {
+  type: "demo-seed",
+  reliability: 0.9,
+  citation: "Causari curated baseline \u2014 computing history"
+};
+function ev3(e) {
+  return { ...e, scope: "world", sources: [src] };
+}
+var computingEvents = [
+  // ── Pre-electronic era ─────────────────────────────────────────────
+  ev3({
+    id: "babbage_engine",
+    title: "Babbage Analytical Engine",
+    description: "Charles Babbage designed the first general-purpose mechanical computer. Never completed, but its architecture \u2014 ALU, control flow, memory \u2014 foreshadowed every von Neumann machine.",
+    yearNum: 1837,
+    yearLabel: "1837",
+    precision: "year",
+    domains: ["technology", "science"],
+    impactScore: 0.72,
+    tags: ["computing", "mechanical", "architecture", "babbage"],
+    wikidataId: "Q151888"
+  }),
+  ev3({
+    id: "lovelace_algorithm",
+    title: "Ada Lovelace \u2014 First Algorithm",
+    description: "Ada Lovelace wrote the first published algorithm (for Bernoulli numbers on the Analytical Engine). More importantly, she articulated the idea that machines could manipulate symbols beyond numbers.",
+    yearNum: 1843,
+    yearLabel: "1843",
+    precision: "year",
+    domains: ["technology", "science"],
+    impactScore: 0.68,
+    tags: ["computing", "algorithm", "programming", "lovelace"],
+    wikidataId: "Q7259"
+  }),
+  ev3({
+    id: "boolean_algebra",
+    title: "Boolean Algebra",
+    description: "George Boole formalized logical operations as algebra. 80 years later, Claude Shannon proved Boolean algebra maps directly to electrical switching circuits \u2014 the mathematical bedrock of all digital hardware.",
+    yearNum: 1854,
+    yearLabel: "1854",
+    precision: "year",
+    domains: ["science", "technology"],
+    impactScore: 0.75,
+    tags: ["logic", "mathematics", "boolean", "foundations"],
+    wikidataId: "Q173183"
+  }),
+  ev3({
+    id: "hollerith_tabulator",
+    title: "Hollerith Tabulating Machine",
+    description: "Herman Hollerith built punch-card tabulators for the 1890 US Census. Reduced processing time from 8 years to 1. His company eventually became IBM.",
+    yearNum: 1890,
+    yearLabel: "1890",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.65,
+    tags: ["computing", "data-processing", "punch-cards", "ibm"],
+    wikidataId: "Q574432"
+  }),
+  // ── Electronic computing (1940s-1950s) ─────────────────────────────
+  ev3({
+    id: "eniac",
+    title: "ENIAC",
+    description: "The first general-purpose electronic digital computer (1945). 17,468 vacuum tubes, 30 tons. Proved that electronic computation was practical, not just theoretical.",
+    yearNum: 1945,
+    yearLabel: "1945",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.82,
+    tags: ["computing", "hardware", "vacuum-tubes", "electronic"],
+    wikidataId: "Q33265"
+  }),
+  ev3({
+    id: "von_neumann_arch",
+    title: "Von Neumann Architecture",
+    description: "John von Neumann described the stored-program concept: instructions and data share the same memory. Nearly every computer built since follows this architecture.",
+    yearNum: 1945,
+    yearLabel: "1945",
+    precision: "year",
+    domains: ["technology", "science"],
+    impactScore: 0.88,
+    tags: ["computing", "architecture", "stored-program", "von-neumann"],
+    wikidataId: "Q753039"
+  }),
+  ev3({
+    id: "transistor",
+    title: "Transistor Invention",
+    description: "Bardeen, Brattain, and Shockley at Bell Labs invented the transistor. Replaced vacuum tubes \u2014 smaller, cheaper, more reliable. The atom of the digital age.",
+    yearNum: 1947,
+    yearLabel: "1947",
+    precision: "year",
+    domains: ["technology", "science"],
+    impactScore: 0.92,
+    tags: ["hardware", "semiconductor", "bell-labs", "electronics"],
+    wikidataId: "Q5339"
+  }),
+  ev3({
+    id: "shannon_info_theory",
+    title: "Shannon Information Theory",
+    description: 'Claude Shannon published "A Mathematical Theory of Communication." Defined bits, entropy, channel capacity. Founded the discipline that underpins compression, encryption, and every digital protocol.',
+    yearNum: 1948,
+    yearLabel: "1948",
+    precision: "year",
+    domains: ["science", "technology"],
+    impactScore: 0.9,
+    tags: ["information", "theory", "shannon", "entropy", "bits"],
+    wikidataId: "Q11153"
+  }),
+  // ── Programming languages & systems (1950s-1970s) ──────────────────
+  ev3({
+    id: "fortran",
+    title: "FORTRAN",
+    description: "First widely-adopted high-level programming language (IBM, John Backus). Proved that compilers could generate code nearly as efficient as hand-written assembly \u2014 making programming accessible to scientists and engineers.",
+    yearNum: 1957,
+    yearLabel: "1957",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.76,
+    tags: ["programming", "language", "compiler", "fortran"],
+    wikidataId: "Q83303"
+  }),
+  ev3({
+    id: "integrated_circuit",
+    title: "Integrated Circuit",
+    description: "Jack Kilby (TI) and Robert Noyce (Fairchild) independently invented the IC. Multiple transistors on a single chip \u2014 launched the miniaturization curve that continues today.",
+    yearNum: 1958,
+    yearLabel: "1958",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.9,
+    tags: ["hardware", "semiconductor", "chip", "miniaturization"],
+    wikidataId: "Q5322"
+  }),
+  ev3({
+    id: "cobol",
+    title: "COBOL",
+    description: "Common Business-Oriented Language. Grace Hopper championed machine-independent business programming. Still runs trillions of dollars in banking transactions daily, 65+ years later.",
+    yearNum: 1959,
+    yearLabel: "1959",
+    precision: "year",
+    domains: ["technology", "economy"],
+    impactScore: 0.68,
+    tags: ["programming", "language", "business", "legacy"],
+    wikidataId: "Q131140"
+  }),
+  ev3({
+    id: "timesharing",
+    title: "Time-Sharing Systems",
+    description: "Compatible Time-Sharing System (CTSS) at MIT allowed multiple users to share a single mainframe interactively. The conceptual ancestor of multi-tenant cloud computing.",
+    yearNum: 1961,
+    yearLabel: "1961",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.7,
+    tags: ["computing", "multi-user", "mainframe", "interactive"],
+    wikidataId: "Q623520"
+  }),
+  ev3({
+    id: "moores_law",
+    title: "Moore's Law",
+    description: "Gordon Moore observed that transistor count doubles roughly every two years. Not a physical law but a self-fulfilling industry roadmap that drove semiconductor investment for 50+ years.",
+    yearNum: 1965,
+    yearLabel: "1965",
+    precision: "year",
+    domains: ["technology", "economy"],
+    impactScore: 0.85,
+    tags: ["hardware", "scaling", "semiconductor", "prediction"],
+    wikidataId: "Q165474"
+  }),
+  ev3({
+    id: "unix",
+    title: "UNIX",
+    description: 'Ken Thompson and Dennis Ritchie built Unix at Bell Labs. "Everything is a file," pipes, small composable tools. The philosophy behind Linux, macOS, Android, and the entire server ecosystem.',
+    yearNum: 1969,
+    yearLabel: "1969",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.88,
+    tags: ["os", "unix", "philosophy", "bell-labs"],
+    wikidataId: "Q11368"
+  }),
+  ev3({
+    id: "relational_db",
+    title: "Relational Database Model",
+    description: 'Edgar Codd at IBM published "A Relational Model of Data for Large Shared Data Banks." Tables, keys, normalization. Led to SQL and every RDBMS from Oracle to PostgreSQL.',
+    yearNum: 1970,
+    yearLabel: "1970",
+    precision: "year",
+    domains: ["technology", "science"],
+    impactScore: 0.84,
+    tags: ["database", "relational", "sql", "data-model"],
+    wikidataId: "Q204200"
+  }),
+  ev3({
+    id: "c_language",
+    title: "C Programming Language",
+    description: "Dennis Ritchie created C to rewrite Unix. Became the lingua franca of systems programming \u2014 Linux kernel, Python interpreter, and most OS kernels are written in C or its descendants.",
+    yearNum: 1972,
+    yearLabel: "1972",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.86,
+    tags: ["programming", "language", "systems", "c"],
+    wikidataId: "Q15777"
+  }),
+  ev3({
+    id: "ethernet",
+    title: "Ethernet",
+    description: "Robert Metcalfe invented Ethernet at Xerox PARC. The standard for local area networking that connected office computers and evolved into the physical backbone of the internet.",
+    yearNum: 1973,
+    yearLabel: "1973",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.76,
+    tags: ["networking", "lan", "protocol", "xerox-parc"],
+    wikidataId: "Q11946"
+  }),
+  ev3({
+    id: "xerox_alto",
+    title: "Xerox Alto / GUI",
+    description: "The first computer with a graphical user interface, mouse, and WYSIWYG editor. Never sold commercially, but directly inspired the Macintosh and Windows \u2014 the interface paradigm 3 billion people use.",
+    yearNum: 1973,
+    yearLabel: "1973",
+    precision: "year",
+    domains: ["technology", "culture"],
+    impactScore: 0.78,
+    tags: ["gui", "mouse", "xerox-parc", "interface"],
+    wikidataId: "Q244125"
+  }),
+  // ── Personal computing & networking (1980s) ────────────────────────
+  ev3({
+    id: "ibm_pc",
+    title: "IBM PC",
+    description: 'IBM legitimized the personal computer for business. Its open architecture spawned the clone industry, created the x86 monopoly, and made "PC-compatible" the default platform for 30 years.',
+    yearNum: 1981,
+    yearLabel: "1981",
+    precision: "year",
+    domains: ["technology", "economy"],
+    impactScore: 0.82,
+    tags: ["pc", "hardware", "ibm", "open-architecture"],
+    wikidataId: "Q190581"
+  }),
+  ev3({
+    id: "tcp_ip_standard",
+    title: "TCP/IP Becomes Standard",
+    description: 'ARPANET adopted TCP/IP as its standard protocol on January 1, 1983 ("flag day"). Unified fragmented networks into one internet. The protocol stack that still runs the global network.',
+    yearNum: 1983,
+    yearLabel: "1983",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.88,
+    tags: ["networking", "protocol", "tcp-ip", "internet"],
+    wikidataId: "Q8795"
+  }),
+  ev3({
+    id: "gnu_project",
+    title: "GNU Project",
+    description: "Richard Stallman launched the GNU Project and the Free Software Foundation. Established the philosophical and legal framework (GPL) for open-source software that powers most of the internet today.",
+    yearNum: 1983,
+    yearLabel: "1983",
+    precision: "year",
+    domains: ["technology", "systems", "philosophy"],
+    impactScore: 0.78,
+    tags: ["open-source", "free-software", "gnu", "gpl"],
+    wikidataId: "Q7598"
+  }),
+  ev3({
+    id: "macintosh",
+    title: "Apple Macintosh",
+    description: "First commercially successful computer with a GUI. Steve Jobs brought the Xerox Alto vision to consumers \u2014 mouse, desktop metaphor, WYSIWYG. Established that interfaces matter as much as compute.",
+    yearNum: 1984,
+    yearLabel: "1984",
+    precision: "year",
+    domains: ["technology", "culture"],
+    impactScore: 0.78,
+    tags: ["gui", "apple", "consumer", "personal-computing"],
+    wikidataId: "Q75687"
+  }),
+  ev3({
+    id: "dns",
+    title: "Domain Name System (DNS)",
+    description: "Paul Mockapetris invented DNS to replace the hosts.txt file. Hierarchical, distributed naming for the internet. Every URL you type resolves through DNS \u2014 the phonebook of the internet.",
+    yearNum: 1983,
+    yearLabel: "1983",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.74,
+    tags: ["networking", "dns", "protocol", "naming"],
+    wikidataId: "Q8767"
+  }),
+  // ── Open source & web (1990s) ──────────────────────────────────────
+  ev3({
+    id: "linux",
+    title: "Linux Kernel",
+    description: "Linus Torvalds released Linux 0.01. Combined with GNU tools, it created a free Unix-like OS. Now runs Android, 96% of cloud servers, most supercomputers, and the infrastructure behind every major web service.",
+    yearNum: 1991,
+    yearLabel: "1991",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.92,
+    tags: ["os", "open-source", "linux", "kernel"],
+    wikidataId: "Q388"
+  }),
+  ev3({
+    id: "python",
+    title: "Python",
+    description: 'Guido van Rossum released Python 0.9. Readability-first design made it the default language for data science, ML, scripting, and teaching. "Life is too short for C" became a movement.',
+    yearNum: 1991,
+    yearLabel: "1991",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.78,
+    tags: ["programming", "language", "python", "readability"],
+    wikidataId: "Q28865"
+  }),
+  ev3({
+    id: "java",
+    title: "Java",
+    description: '"Write once, run anywhere." James Gosling at Sun Microsystems created the JVM abstraction. Dominated enterprise development for 20 years and inspired the managed-runtime approach of C#, Kotlin, and more.',
+    yearNum: 1995,
+    yearLabel: "1995",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.8,
+    tags: ["programming", "language", "jvm", "enterprise"],
+    wikidataId: "Q251"
+  }),
+  ev3({
+    id: "javascript",
+    title: "JavaScript",
+    description: "Brendan Eich created JavaScript in 10 days at Netscape. Became the only language that runs natively in browsers \u2014 and now, via Node.js, everywhere else. The most deployed programming language in history.",
+    yearNum: 1995,
+    yearLabel: "1995",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.84,
+    tags: ["programming", "language", "javascript", "web", "browser"],
+    wikidataId: "Q2005"
+  }),
+  ev3({
+    id: "postgresql",
+    title: "PostgreSQL",
+    description: "Born from Berkeley's POSTGRES project. The open-source relational database that became the default choice for startups and enterprises alike. Extensible, standards-compliant, and free.",
+    yearNum: 1996,
+    yearLabel: "1996",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.74,
+    tags: ["database", "relational", "postgresql", "open-source"],
+    wikidataId: "Q192490"
+  }),
+  ev3({
+    id: "google_pagerank",
+    title: "Google / PageRank",
+    description: "Larry Page and Sergey Brin applied link analysis to web search. Ranked pages by how many quality pages link to them. Solved web discovery and built the largest advertising business in history.",
+    yearNum: 1998,
+    yearLabel: "1998",
+    precision: "year",
+    domains: ["technology", "economy"],
+    impactScore: 0.88,
+    tags: ["search", "web", "google", "algorithm", "advertising"],
+    wikidataId: "Q9366"
+  }),
+  // ── Modern dev tooling & practices (2000s) ─────────────────────────
+  ev3({
+    id: "rest_api",
+    title: "REST Architecture",
+    description: "Roy Fielding's doctoral thesis defined REST \u2014 stateless, resource-oriented, HTTP-native API design. Became the dominant pattern for web services, replacing SOAP/XML with simpler JSON APIs.",
+    yearNum: 2e3,
+    yearLabel: "2000",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.74,
+    tags: ["api", "rest", "architecture", "web-services"],
+    wikidataId: "Q749568"
+  }),
+  ev3({
+    id: "agile_manifesto",
+    title: "Agile Manifesto",
+    description: '17 software developers signed the Agile Manifesto at Snowbird. "Individuals and interactions over processes and tools." Replaced waterfall with iterative development and reshaped how the industry ships software.',
+    yearNum: 2001,
+    yearLabel: "2001",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.72,
+    tags: ["methodology", "agile", "software-engineering", "process"],
+    wikidataId: "Q326523"
+  }),
+  ev3({
+    id: "git",
+    title: "Git",
+    description: "Linus Torvalds built Git in 2 weeks after BitKeeper revoked free access. Distributed version control that made branching cheap and merging sane. Foundation of modern collaborative development.",
+    yearNum: 2005,
+    yearLabel: "2005",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.82,
+    tags: ["version-control", "git", "distributed", "collaboration"],
+    wikidataId: "Q186055"
+  }),
+  ev3({
+    id: "aws",
+    title: "AWS / Cloud Computing",
+    description: "Amazon Web Services launched S3 and EC2. Turned infrastructure into an API call. No more buying servers \u2014 just rent compute by the hour. Created the cloud industry and enabled the startup explosion.",
+    yearNum: 2006,
+    yearLabel: "2006",
+    precision: "year",
+    domains: ["technology", "economy"],
+    impactScore: 0.88,
+    tags: ["cloud", "infrastructure", "aws", "iaas", "saas"],
+    wikidataId: "Q456157"
+  }),
+  ev3({
+    id: "github",
+    title: "GitHub",
+    description: "Tom Preston-Werner, Chris Wanstrath, PJ Hyett launched GitHub. Git + social features + pull requests = the social network for code. 100M+ developers, the world's largest open-source ecosystem.",
+    yearNum: 2008,
+    yearLabel: "2008",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.8,
+    tags: ["collaboration", "git", "open-source", "social"],
+    wikidataId: "Q364"
+  }),
+  ev3({
+    id: "stackoverflow",
+    title: "Stack Overflow",
+    description: 'Joel Spolsky and Jeff Atwood built the Q&A site that replaced expert forums. Gamified knowledge sharing for developers. Changed how an entire generation learned to code \u2014 "just Google it" really means "find the SO answer."',
+    yearNum: 2008,
+    yearLabel: "2008",
+    precision: "year",
+    domains: ["technology", "culture"],
+    impactScore: 0.72,
+    tags: ["knowledge", "community", "qa", "developer"],
+    wikidataId: "Q549037"
+  }),
+  ev3({
+    id: "nodejs",
+    title: "Node.js",
+    description: "Ryan Dahl put V8 (Chrome's JS engine) on the server. JavaScript everywhere \u2014 frontend and backend in one language. Spawned npm (largest package registry), enabled real-time web apps, and created the full-stack JS ecosystem.",
+    yearNum: 2009,
+    yearLabel: "2009",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.78,
+    tags: ["javascript", "runtime", "server", "npm", "fullstack"],
+    wikidataId: "Q756100"
+  }),
+  ev3({
+    id: "golang",
+    title: "Go Language",
+    description: "Rob Pike, Ken Thompson, Robert Griesemer at Google created Go. Fast compilation, built-in concurrency (goroutines), simplicity-by-design. Became the language of cloud infrastructure \u2014 Docker, Kubernetes, Terraform all written in Go.",
+    yearNum: 2009,
+    yearLabel: "2009",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.72,
+    tags: ["programming", "language", "go", "golang", "concurrency", "cloud"],
+    wikidataId: "Q37227"
+  }),
+  ev3({
+    id: "nosql_movement",
+    title: "NoSQL Movement",
+    description: "MongoDB, Cassandra, Redis emerged as alternatives to relational databases. Trade consistency for scalability. Suited for web-scale data that doesn't fit neatly into tables.",
+    yearNum: 2009,
+    yearLabel: "2009",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.7,
+    tags: ["database", "nosql", "mongodb", "redis", "scalability"],
+    wikidataId: "Q621284"
+  }),
+  ev3({
+    id: "oauth",
+    title: "OAuth 2.0",
+    description: 'Standardized delegated authorization for the web. "Sign in with Google/GitHub" \u2014 users grant limited access without sharing passwords. The identity layer of the modern web.',
+    yearNum: 2010,
+    yearLabel: "2010",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.68,
+    tags: ["security", "auth", "oauth", "identity", "protocol"],
+    wikidataId: "Q384157"
+  }),
+  // ── Modern infrastructure (2010s) ──────────────────────────────────
+  ev3({
+    id: "typescript",
+    title: "TypeScript",
+    description: "Microsoft's Anders Hejlsberg added static types to JavaScript. Catches bugs at compile time, enables IDE autocompletion, scales JS to large codebases. Now used by most major JS projects.",
+    yearNum: 2012,
+    yearLabel: "2012",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.74,
+    tags: ["programming", "language", "typescript", "types", "javascript"],
+    wikidataId: "Q978185"
+  }),
+  ev3({
+    id: "docker",
+    title: "Docker",
+    description: 'Solomon Hykes introduced Linux containers to the masses. "Build once, run anywhere" \u2014 for real this time. Package your app with its dependencies. Killed "works on my machine" and enabled microservices at scale.',
+    yearNum: 2013,
+    yearLabel: "2013",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.82,
+    tags: ["containers", "devops", "docker", "deployment"],
+    wikidataId: "Q15206305"
+  }),
+  ev3({
+    id: "reactjs",
+    title: "React.js",
+    description: "Facebook open-sourced React. Component-based UI with virtual DOM and one-way data flow. Changed frontend development from jQuery spaghetti to declarative, composable interfaces. Spawned React Native, Next.js, and the component ecosystem.",
+    yearNum: 2013,
+    yearLabel: "2013",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.78,
+    tags: ["frontend", "react", "javascript", "ui", "component"],
+    wikidataId: "Q19399674"
+  }),
+  ev3({
+    id: "kubernetes",
+    title: "Kubernetes",
+    description: "Google open-sourced its container orchestration system. Automates deployment, scaling, and management of containerized applications. Became the operating system of the cloud \u2014 the de facto standard for production workloads.",
+    yearNum: 2014,
+    yearLabel: "2014",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.82,
+    tags: ["containers", "orchestration", "kubernetes", "k8s", "cloud", "devops"],
+    wikidataId: "Q22661306"
+  }),
+  ev3({
+    id: "terraform",
+    title: "Terraform / Infrastructure as Code",
+    description: "HashiCorp released Terraform. Describe infrastructure in declarative config files, version it in Git, apply changes reproducibly. IaC completed the DevOps revolution \u2014 infrastructure became software.",
+    yearNum: 2014,
+    yearLabel: "2014",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.72,
+    tags: ["iac", "terraform", "devops", "infrastructure", "declarative"],
+    wikidataId: "Q21080311"
+  }),
+  ev3({
+    id: "rust_1_0",
+    title: "Rust 1.0",
+    description: "Mozilla released Rust 1.0. Memory safety without garbage collection \u2014 the borrow checker catches use-after-free at compile time. Growing adoption in systems programming where C/C++ dominated for decades.",
+    yearNum: 2015,
+    yearLabel: "2015",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.72,
+    tags: ["programming", "language", "rust", "memory-safety", "systems"],
+    wikidataId: "Q575650"
+  }),
+  ev3({
+    id: "graphql",
+    title: "GraphQL",
+    description: "Facebook open-sourced GraphQL. Client specifies exactly what data it needs \u2014 no over-fetching, no under-fetching. Alternative to REST that works well for complex, nested data requirements.",
+    yearNum: 2015,
+    yearLabel: "2015",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.65,
+    tags: ["api", "graphql", "query-language", "facebook"],
+    wikidataId: "Q25104949"
+  }),
+  ev3({
+    id: "vscode",
+    title: "VS Code",
+    description: "Microsoft released Visual Studio Code. Electron-based, extensible, free. Won the editor war through the extension marketplace and language server protocol (LSP). Now used by ~70% of developers.",
+    yearNum: 2015,
+    yearLabel: "2015",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.72,
+    tags: ["editor", "ide", "vscode", "developer-tools", "microsoft"],
+    wikidataId: "Q20829091"
+  }),
+  ev3({
+    id: "websockets",
+    title: "WebSocket Protocol (RFC 6455)",
+    description: "Full-duplex communication over a single TCP connection. Enabled real-time web applications \u2014 chat, live dashboards, collaborative editing, gaming \u2014 without HTTP polling hacks.",
+    yearNum: 2011,
+    yearLabel: "2011",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.64,
+    tags: ["protocol", "websocket", "websockets", "real-time", "web"],
+    wikidataId: "Q859917"
+  }),
+  ev3({
+    id: "mcp_protocol",
+    title: "Model Context Protocol (MCP)",
+    description: 'Anthropic open-sourced MCP \u2014 a standard for connecting AI agents to external tools and data sources. Agents can call tools, read resources, and compose capabilities. The "USB-C for AI" \u2014 one protocol to connect any agent to any tool.',
+    yearNum: 2024,
+    yearLabel: "2024",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.78,
+    tags: ["ai", "protocol", "mcp", "agents", "tools", "anthropic"],
+    wikidataId: "Q130901288"
+  }),
+  ev3({
+    id: "microservices",
+    title: "Microservices Architecture",
+    description: "Martin Fowler and James Lewis codified the microservices pattern. Break monoliths into small, independently deployable services. Enabled by Docker + Kubernetes, adopted by Netflix, Amazon, Google.",
+    yearNum: 2014,
+    yearLabel: "2014",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.7,
+    tags: ["architecture", "microservices", "distributed", "pattern"],
+    wikidataId: "Q18344264"
+  })
+];
+
+// ../../packages/ckg/dist/seed/links-computing.js
+var seed3 = (fromEvent, toEvent, rel, evidence, confidence) => ({
+  id: `${fromEvent}--${rel}-->${toEvent}`,
+  fromEvent,
+  toEvent,
+  relationship: rel,
+  confidence: confidence ?? (rel === "caused" ? 0.9 : 0.8),
+  evidence,
+  sources: [{ type: "demo-seed", reliability: 0.9, citation: "Causari curated baseline \u2014 computing" }],
+  contributedBy: "system",
+  validated: true,
+  scope: "world"
+});
+var computingLinks = [
+  // ── Pre-electronic foundations ──────────────────────────────────────
+  seed3("babbage_engine", "lovelace_algorithm", "enabled", "Lovelace wrote her algorithm specifically for the Analytical Engine. No machine concept \u2192 no algorithm concept."),
+  seed3("lovelace_algorithm", "turing_m", "inspired", "Lovelace articulated that machines could manipulate symbols beyond numbers \u2014 the philosophical seed Turing formalized 93 years later.", 0.6),
+  seed3("boolean_algebra", "shannon_info_theory", "enabled", "Shannon's 1937 master's thesis proved Boolean algebra maps to switching circuits. His 1948 information theory built on this foundation."),
+  seed3("boolean_algebra", "eniac", "enabled", "ENIAC's logic circuits were direct implementations of Boolean operations in electronic hardware."),
+  seed3("hollerith_tabulator", "eniac", "enabled", "Hollerith's tabulating machines proved mechanical data processing was commercially viable, creating institutional demand for faster electronic alternatives."),
+  // ── Birth of electronic computing ──────────────────────────────────
+  seed3("eniac", "von_neumann_arch", "enabled", `Von Neumann observed ENIAC's limitations (hard-wired programs) and proposed the stored-program concept in his "First Draft" report based on the ENIAC project.`),
+  seed3("von_neumann_arch", "fortran", "enabled", "Stored-program computers made high-level languages possible \u2014 instructions could be compiled into memory rather than hard-wired."),
+  seed3("transistor", "integrated_circuit", "caused", "The IC is literally multiple transistors fabricated on a single semiconductor substrate. No transistor \u2192 no IC.", 0.95),
+  seed3("integrated_circuit", "moores_law", "caused", "Moore observed the doubling trend specifically in integrated circuit transistor counts. The IC is the object of the law.", 0.92),
+  seed3("moores_law", "ibm_pc", "enabled", "Exponential cost reduction in chips made personal computers economically viable for consumers and small businesses."),
+  seed3("transistor", "eniac", "enabled", "While ENIAC used vacuum tubes, the transistor (invented 2 years later) was critical for the reliability needed in subsequent computers.", 0.5),
+  // ── Programming languages chain ────────────────────────────────────
+  seed3("fortran", "cobol", "enabled", "FORTRAN proved that high-level compiled languages were practical. COBOL applied the same approach to business data processing 2 years later."),
+  seed3("fortran", "c_language", "enabled", "FORTRAN established the compiled-language paradigm. C evolved through BCPL \u2192 B \u2192 C, each building on the concept that compilers could be efficient."),
+  seed3("c_language", "unix", "caused", "Unix was rewritten in C in 1973 \u2014 the first OS written in a high-level language. C and Unix co-evolved; each made the other viable.", 0.92),
+  seed3("unix", "c_language", "accelerated", "Unix's adoption spread C everywhere. Every Unix system needed a C compiler, creating a self-reinforcing ecosystem.", 0.85),
+  seed3("c_language", "python", "enabled", "CPython (the reference Python interpreter) is written in C. Python's C extension API became its superpower for scientific computing."),
+  seed3("c_language", "java", "enabled", "Java's syntax is directly derived from C/C++. Gosling designed Java to be familiar to C programmers while adding memory safety."),
+  seed3("c_language", "javascript", "enabled", "JavaScript borrowed C-family syntax (braces, semicolons, operators) to feel familiar to web developers already trained on C/C++/Java."),
+  seed3("java", "golang", "inspired", "Go was designed as a reaction to Java/C++ complexity. Pike and Thompson kept what worked (static typing, compilation) and stripped what didn't (inheritance, generics initially, build complexity).", 0.7),
+  seed3("c_language", "rust_1_0", "enabled", "Rust targets the same systems-programming niche as C/C++. Its borrow checker solves the memory safety problems that decades of C code demonstrated."),
+  seed3("javascript", "nodejs", "caused", "Node.js is V8 (Chrome's JavaScript engine) on the server. No JavaScript \u2192 no Node.js.", 0.95),
+  seed3("javascript", "typescript", "caused", "TypeScript is a strict syntactical superset of JavaScript. It exists only because JavaScript needed types at scale.", 0.95),
+  seed3("java", "postgresql", "enabled", "While PostgreSQL predates Java, the JDBC driver and enterprise Java ecosystem drove PostgreSQL adoption in production systems.", 0.5),
+  // ── Operating systems & infrastructure ──────────────────────────────
+  seed3("unix", "linux", "inspired", "Torvalds built Linux as a free Unix-like kernel. Same philosophy (everything is a file, pipes, small tools) reimplemented from scratch to avoid AT&T licensing.", 0.9),
+  seed3("gnu_project", "linux", "enabled", 'GNU provided the userland tools (gcc, bash, coreutils) that Linux needed. "GNU/Linux" \u2014 the kernel alone is useless without the toolchain.', 0.9),
+  seed3("linux", "aws", "enabled", "AWS runs primarily on Linux. Cloud computing is economically viable because the OS layer is free and customizable."),
+  seed3("linux", "docker", "caused", "Docker relies on Linux kernel features (cgroups, namespaces) for containerization. Linux containers are the foundation Docker productized.", 0.92),
+  seed3("linux", "kubernetes", "enabled", "Kubernetes orchestrates Linux containers. Google's internal Borg system (which inspired K8s) ran on Linux clusters."),
+  seed3("linux", "golang", "enabled", "Go was designed at Google for Linux server infrastructure. Its concurrency model targets the Linux process/thread model.", 0.6),
+  // ── Networking chain ───────────────────────────────────────────────
+  seed3("ethernet", "tcp_ip_standard", "enabled", "Ethernet provided the physical layer for local networks. TCP/IP provided the protocol layer that unified local networks into the internet."),
+  seed3("tcp_ip_standard", "dns", "enabled", "DNS was created to make TCP/IP networks human-navigable. IP addresses need names; DNS provides the mapping."),
+  seed3("tcp_ip_standard", "web", "enabled", "HTTP runs on TCP/IP. The World Wide Web is an application-layer protocol built on top of the internet's transport layer."),
+  seed3("dns", "web", "enabled", "URLs use domain names. Without DNS, the web would require memorizing IP addresses \u2014 adoption would have stalled."),
+  seed3("web", "javascript", "caused", "JavaScript was created in 10 days specifically for Netscape Navigator \u2014 a web browser. No web \u2192 no JavaScript.", 0.95),
+  seed3("web", "rest_api", "enabled", "REST was designed around HTTP semantics (GET, POST, PUT, DELETE). It's a web-native architectural style."),
+  seed3("web", "google_pagerank", "caused", "Google exists because the web created an information discovery problem. PageRank is specifically a web graph algorithm.", 0.92),
+  seed3("web", "websockets", "enabled", "WebSockets upgrade HTTP connections to full-duplex. Born from the need for real-time web apps that HTTP request-response couldn't serve."),
+  // ── GUI & developer experience ─────────────────────────────────────
+  seed3("xerox_alto", "macintosh", "caused", "Steve Jobs visited Xerox PARC in 1979 and saw the Alto. The Macintosh GUI was directly inspired by that visit \u2014 Apple hired PARC engineers.", 0.9),
+  seed3("macintosh", "web", "enabled", "GUI computing normalized visual interaction patterns (point, click, navigate) that the web browser adopted. Hyperlinks are just clickable text.", 0.6),
+  seed3("vscode", "typescript", "accelerated", "VS Code is written in TypeScript and provides best-in-class TypeScript support. Each drives adoption of the other.", 0.7),
+  // ── Version control & collaboration ────────────────────────────────
+  seed3("linux", "git", "caused", "Torvalds built Git specifically to manage the Linux kernel source after the BitKeeper license was revoked. Linux's scale requirements shaped Git's design.", 0.92),
+  seed3("git", "github", "caused", "GitHub is a hosted Git service. No Git \u2192 no GitHub. GitHub added the social and PR workflow layer on top.", 0.95),
+  seed3("github", "linux", "accelerated", "GitHub made open-source contributions trivially easy \u2014 fork, branch, PR. Thousands of Linux ecosystem projects flourished on GitHub, accelerating the kernel's surrounding toolchain adoption.", 0.7),
+  // ── Cloud & DevOps ─────────────────────────────────────────────────
+  seed3("aws", "docker", "enabled", "Cloud made disposable infrastructure normal. Docker made the deployment unit portable. Together they created the container-in-the-cloud paradigm."),
+  seed3("docker", "kubernetes", "caused", "Kubernetes orchestrates Docker containers (and OCI containers). Docker created the packaging format; K8s automated running them at scale.", 0.9),
+  seed3("docker", "microservices", "enabled", "Containers made microservices practical. Each service in its own container, independently deployable. Before Docker, running 50 services was an ops nightmare."),
+  seed3("kubernetes", "terraform", "accelerated", "K8s popularized declarative infrastructure. Terraform extended the same principle to cloud resources beyond containers.", 0.65),
+  seed3("agile_manifesto", "docker", "enabled", 'Agile demanded frequent, reliable deployments. Docker made "deploy often" technically feasible by solving environment consistency.', 0.6),
+  seed3("agile_manifesto", "git", "enabled", "Agile's emphasis on collaboration and frequent integration drove demand for better version control. Git's branching model fits agile workflows perfectly.", 0.6),
+  // ── Data layer ─────────────────────────────────────────────────────
+  seed3("relational_db", "postgresql", "caused", "PostgreSQL implements Codd's relational model. It's a direct descendant of the POSTGRES project, which was itself an evolution of the relational concept.", 0.92),
+  seed3("relational_db", "nosql_movement", "enabled", "NoSQL was a reaction to relational DB limitations at web scale. You need the relational model to exist before you can consciously reject it for specific use cases."),
+  seed3("aws", "nosql_movement", "enabled", "Cloud-scale applications exposed relational DB scaling limits. DynamoDB, BigTable \u2014 cloud providers built NoSQL to handle their own scale."),
+  seed3("rest_api", "graphql", "enabled", "GraphQL was created at Facebook to solve REST over-fetching/under-fetching. REST had to exist and show its limitations before GraphQL made sense."),
+  seed3("rest_api", "oauth", "enabled", "OAuth delegates authorization for REST APIs. The protocol assumes HTTP/REST-style resource access patterns."),
+  // ── Knowledge & community ──────────────────────────────────────────
+  seed3("web", "stackoverflow", "enabled", "Stack Overflow is a web application built for web-era developer culture. Search-indexed Q&A only works because the web makes content discoverable."),
+  seed3("stackoverflow", "chatgpt", "enabled", "ChatGPT's coding ability was partly trained on Stack Overflow data. SO's structured Q&A format provided high-quality training signal.", 0.6),
+  // ── Cross-links to existing graph ──────────────────────────────────
+  seed3("shannon_info_theory", "internet", "enabled", "Shannon's theory defined the theoretical limits of data transmission. TCP/IP and every network protocol operate within Shannon capacity bounds."),
+  seed3("timesharing", "internet", "enabled", "Time-sharing systems created the demand for remote access and resource sharing that ARPANET addressed."),
+  seed3("von_neumann_arch", "turing_m", "enabled", "Von Neumann's stored-program architecture is a practical realization of Turing's universal machine concept.", 0.85),
+  seed3("ibm_pc", "web", "enabled", "The PC installed base created the consumer market for the web. Millions of networked PCs \u2192 millions of potential web users."),
+  seed3("ibm_pc", "macintosh", "accelerated", "IBM PC's success proved the personal computer market. Apple positioned the Macintosh as the premium alternative.", 0.65),
+  seed3("google_pagerank", "aws", "enabled", "Google proved that commodity hardware at scale could be more powerful than expensive servers. AWS applied the same economics to infrastructure-as-a-service.", 0.6),
+  seed3("github", "vscode", "enabled", "Microsoft acquired GitHub (2018) and deeply integrated it with VS Code. GitHub Copilot, Codespaces, and PR reviews live inside VS Code.", 0.7),
+  seed3("nodejs", "reactjs", "enabled", "React's toolchain (webpack, babel, create-react-app) runs on Node.js. npm is the distribution mechanism for React and its ecosystem."),
+  seed3("reactjs", "graphql", "accelerated", "Facebook developed both React and GraphQL. React's component model pairs well with GraphQL's declarative data fetching (Relay).", 0.6),
+  seed3("golang", "docker", "caused", "Docker is written in Go. Go's static binaries and Linux syscall access made it ideal for container runtime development.", 0.85),
+  seed3("golang", "kubernetes", "caused", "Kubernetes is written in Go. Google chose Go for K8s because of its concurrency model and deployment simplicity.", 0.85),
+  seed3("golang", "terraform", "caused", "Terraform is written in Go. HashiCorp adopted Go for all its infrastructure tools (Consul, Vault, Nomad) for the same static-binary advantages.", 0.85),
+  seed3("moores_law", "transformer", "enabled", "Transformer training requires massive GPU compute. 50+ years of Moore's Law created the hardware base that makes attention-at-scale feasible."),
+  seed3("moores_law", "iphone", "enabled", "A smartphone is only possible when chips are small, powerful, and cheap enough to fit in a pocket. Moore's Law made that happen."),
+  seed3("aws", "ai", "enabled", "Cloud computing provides the elastic GPU clusters needed for LLM training and inference. No cloud \u2192 AI stays in university labs."),
+  seed3("python", "ai", "enabled", "Python is the lingua franca of AI/ML (TensorFlow, PyTorch, scikit-learn, numpy). Its readability + C extensions made it the bridge between researchers and GPUs."),
+  seed3("imagenet", "aws", "enabled", "Large-scale datasets like ImageNet required cloud storage and compute for distribution and training. The data-hungry ML era drove cloud GPU demand.", 0.5),
+  // ── Developer culture connections ──────────────────────────────────
+  seed3("gnu_project", "agile_manifesto", "enabled", "Free software culture established that developers could organize around shared values, not just employers. Agile Manifesto was written by independent consultants, not corporate mandates.", 0.5),
+  seed3("git", "microservices", "enabled", "Microservices require independent repos or monorepo strategies with good branching. Git's cheap branching made polyrepo microservices manageable.", 0.55),
+  seed3("stackoverflow", "vscode", "enabled", "VS Code's extension ecosystem mirrors SO's community model \u2014 developers sharing tools and knowledge freely. Marketplace adoption echoes SO's reputation system.", 0.4),
+  seed3("typescript", "reactjs", "accelerated", "TypeScript + React became the dominant frontend stack. Type-safe props, hooks, and component APIs caught bugs earlier and improved DX.", 0.7),
+  seed3("rest_api", "mcp_protocol", "enabled", "MCP borrows REST-like resource/tool patterns and applies them to AI agent-tool communication. The resource-oriented thinking came from REST.", 0.6),
+  seed3("chatgpt", "mcp_protocol", "enabled", "The explosion of AI agents after ChatGPT created demand for a standard protocol connecting agents to tools. MCP fills the same role HTTP filled for the web.", 0.75),
+  seed3("kubernetes", "microservices", "accelerated", "K8s made microservices operationally viable. Service discovery, load balancing, rolling deploys \u2014 K8s automates the hard parts of running many small services.", 0.8),
+  seed3("websockets", "nodejs", "accelerated", "Node.js's event-driven architecture handles thousands of WebSocket connections efficiently. Real-time web apps (chat, collab editing) drove Node adoption.", 0.65)
+];
+
+// ../../packages/ckg/dist/seed/events-web-ecosystem.js
+var src2 = {
+  type: "demo-seed",
+  reliability: 0.9,
+  citation: "Causari curated baseline \u2014 web ecosystem"
+};
+function ev4(e) {
+  return { ...e, scope: "world", sources: [src2] };
+}
+var webEcosystemEvents = [
+  // ── CSS & styling ────────────────────────────────────────────────────
+  ev4({
+    id: "sass",
+    title: "Sass (CSS Preprocessor)",
+    description: "Hampton Catlin created Sass \u2014 the first CSS preprocessor. Variables, nesting, mixins made stylesheets maintainable at scale. CSS-in-JS and Tailwind exist partly in reaction to the complexity Sass revealed.",
+    yearNum: 2006,
+    yearLabel: "2006",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.62,
+    tags: ["css", "sass", "preprocessor", "styling", "frontend"],
+    wikidataId: "Q1068305"
+  }),
+  ev4({
+    id: "bootstrap",
+    title: "Bootstrap CSS Framework",
+    description: "Twitter engineers released Bootstrap \u2014 the grid system and component library that standardized responsive web design. Made professional-looking UIs accessible to backend developers and bootstrapped startups for a decade.",
+    yearNum: 2011,
+    yearLabel: "2011",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.68,
+    tags: ["css", "bootstrap", "responsive", "grid", "component-library"],
+    wikidataId: "Q1076900"
+  }),
+  ev4({
+    id: "tailwind",
+    title: "Tailwind CSS",
+    description: "Adam Wathan released Tailwind \u2014 utility-first CSS that puts styling directly in HTML. Challenged the semantic CSS paradigm. Paired with component frameworks (React, Vue), it became the default design system approach for modern web apps.",
+    yearNum: 2017,
+    yearLabel: "2017",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.68,
+    tags: ["css", "tailwind", "utility-first", "design-system", "frontend"],
+    wikidataId: "Q95614011"
+  }),
+  // ── DOM & early JS ecosystem ─────────────────────────────────────────
+  ev4({
+    id: "jquery",
+    title: "jQuery",
+    description: 'John Resig released jQuery \u2014 "write less, do more." Cross-browser DOM manipulation, Ajax, and event handling in one small library. Ran on 73% of websites at its peak. Established JavaScript as a viable platform and created the library ecosystem.',
+    yearNum: 2006,
+    yearLabel: "2006",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.72,
+    tags: ["javascript", "jquery", "dom", "ajax", "library"],
+    wikidataId: "Q230036"
+  }),
+  ev4({
+    id: "ajax",
+    title: "Ajax (Asynchronous JavaScript)",
+    description: 'Jesse James Garrett coined "Ajax" to describe asynchronous data fetching without full page reloads. Gmail and Google Maps demonstrated the paradigm. Transformed websites into interactive applications and defined the "Web 2.0" era.',
+    yearNum: 2005,
+    yearLabel: "2005",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.72,
+    tags: ["javascript", "ajax", "async", "web2", "xhr"],
+    wikidataId: "Q179239"
+  }),
+  // ── Package management ────────────────────────────────────────────────
+  ev4({
+    id: "npm",
+    title: "npm (Node Package Manager)",
+    description: `Isaac Schlueter built npm as the package manager for Node.js. Became the world's largest software registry \u2014 2M+ packages. "npm install" became the universal developer onboarding command and created the composable JS module ecosystem.`,
+    yearNum: 2010,
+    yearLabel: "2010",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.78,
+    tags: ["npm", "package-manager", "registry", "nodejs", "javascript"],
+    wikidataId: "Q7108012"
+  }),
+  // ── Frontend frameworks ──────────────────────────────────────────────
+  ev4({
+    id: "angularjs",
+    title: "AngularJS",
+    description: "Misko Hevery at Google released AngularJS \u2014 the first comprehensive MVC framework for JavaScript. Two-way data binding and dependency injection brought enterprise software patterns to the browser. Dominated enterprise apps 2012-2016.",
+    yearNum: 2010,
+    yearLabel: "2010",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.7,
+    tags: ["javascript", "angular", "framework", "mvc", "google"],
+    wikidataId: "Q12878963"
+  }),
+  ev4({
+    id: "angular2",
+    title: "Angular (v2+)",
+    description: "Google completely rewrote AngularJS in TypeScript as Angular 2 \u2014 components, RxJS observables, CLI, full TypeScript integration. Controversial breaking change but established TypeScript as the enterprise JS standard and popularized observable-based architecture.",
+    yearNum: 2016,
+    yearLabel: "2016",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.66,
+    tags: ["typescript", "angular", "framework", "rxjs", "enterprise"],
+    wikidataId: "Q28028784"
+  }),
+  ev4({
+    id: "vuejs",
+    title: "Vue.js",
+    description: 'Evan You (ex-Google) released Vue \u2014 the "progressive framework." Easier entry point than Angular, simpler mental model than early React. Became the dominant frontend framework in Asia and the default choice for projects wanting React-like UI without the full ecosystem overhead.',
+    yearNum: 2014,
+    yearLabel: "2014",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.72,
+    tags: ["javascript", "vue", "framework", "progressive", "frontend"],
+    wikidataId: "Q28026027"
+  }),
+  ev4({
+    id: "svelte",
+    title: "Svelte",
+    description: "Rich Harris released Svelte \u2014 the first compile-time UI framework. No virtual DOM, no runtime overhead. Components compile to vanilla JS. Challenged React/Vue's runtime paradigm and proved that the framework can live in the compiler, not the browser.",
+    yearNum: 2016,
+    yearLabel: "2016",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.64,
+    tags: ["javascript", "svelte", "compiler", "framework", "no-virtual-dom"],
+    wikidataId: "Q60055583"
+  }),
+  ev4({
+    id: "redux",
+    title: "Redux",
+    description: "Dan Abramov released Redux \u2014 predictable state management for JavaScript. Single store, pure reducers, time-travel debugging. Became the dominant React state solution and popularized functional programming patterns (immutability, pure functions) across frontend development.",
+    yearNum: 2015,
+    yearLabel: "2015",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.64,
+    tags: ["javascript", "redux", "state-management", "react", "functional"],
+    wikidataId: "Q22001046"
+  }),
+  // ── Build tooling ─────────────────────────────────────────────────────
+  ev4({
+    id: "webpack",
+    title: "Webpack",
+    description: "Tobias Koppers built Webpack \u2014 the module bundler that made modern JS development possible. Bundle everything (JS, CSS, images) into browser-deliverable assets. Code splitting, tree shaking, hot module replacement. The infrastructure behind React, Vue, and Angular CLIs.",
+    yearNum: 2012,
+    yearLabel: "2012",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.7,
+    tags: ["javascript", "webpack", "bundler", "build-tool", "module"],
+    wikidataId: "Q22001105"
+  }),
+  ev4({
+    id: "babel",
+    title: "Babel (JS Transpiler)",
+    description: "Sebastian McKenzie built Babel \u2014 the JavaScript compiler that lets developers use tomorrow's syntax today. Write ES2015+ code, ship ES5 that works everywhere. Unlocked JSX for React, decorators for Angular, and every JS proposal before browsers shipped it.",
+    yearNum: 2014,
+    yearLabel: "2014",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.66,
+    tags: ["javascript", "babel", "transpiler", "compiler", "es6"],
+    wikidataId: "Q22011024"
+  }),
+  ev4({
+    id: "vite",
+    title: "Vite",
+    description: "Evan You built Vite \u2014 the build tool that uses native ES modules in dev and Rollup for production. Starts in milliseconds vs seconds for Webpack. Redefined developer experience expectations for frontend tooling and triggered a Rust-powered build tool generation.",
+    yearNum: 2020,
+    yearLabel: "2020",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.68,
+    tags: ["javascript", "vite", "bundler", "build-tool", "esm", "dx"],
+    wikidataId: "Q105853128"
+  }),
+  ev4({
+    id: "esbuild",
+    title: "esbuild",
+    description: "Evan Wallace wrote esbuild in Go \u2014 a JavaScript bundler 10-100x faster than Webpack. Proved that build tools written in compiled languages could transform developer experience. Became the bundler inside Vite and accelerated the move away from JS-based toolchain.",
+    yearNum: 2020,
+    yearLabel: "2020",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.6,
+    tags: ["javascript", "esbuild", "bundler", "go", "fast", "toolchain"]
+  }),
+  // ── Meta-frameworks (full-stack) ─────────────────────────────────────
+  ev4({
+    id: "nextjs",
+    title: "Next.js",
+    description: "Vercel released Next.js \u2014 React with server-side rendering, file-based routing, API routes, and zero config. Solved the hardest React problems (SEO, performance, data fetching) out of the box. Became the dominant React production framework and shaped how Vercel became a $2.5B company.",
+    yearNum: 2016,
+    yearLabel: "2016",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.76,
+    tags: ["react", "nextjs", "ssr", "framework", "vercel", "fullstack"],
+    wikidataId: "Q56061525"
+  }),
+  ev4({
+    id: "sveltekit",
+    title: "SvelteKit",
+    description: "The official Svelte full-stack framework. File-based routing, server-side rendering, adapters for any deployment target. Completed the compile-time framework vision \u2014 a full production framework with no runtime overhead.",
+    yearNum: 2020,
+    yearLabel: "2020",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.58,
+    tags: ["svelte", "sveltekit", "framework", "ssr", "fullstack"],
+    wikidataId: "Q108508847"
+  }),
+  ev4({
+    id: "remix",
+    title: "Remix",
+    description: "Ryan Florence and Michael Jackson built Remix \u2014 React full-stack framework built on web platform primitives (forms, fetch, progressive enhancement). Acquired by Shopify. Pushed back against client-side-heavy React apps and revived server-side values in a React world.",
+    yearNum: 2021,
+    yearLabel: "2021",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.6,
+    tags: ["react", "remix", "framework", "ssr", "web-platform", "fullstack"],
+    wikidataId: "Q110628793"
+  }),
+  ev4({
+    id: "astro",
+    title: "Astro",
+    description: 'Fred K. Schott built Astro \u2014 the "islands architecture" framework. Ship zero JS by default; hydrate only interactive components. Ideal for content sites. Popularized the concept of partial hydration and multi-framework islands.',
+    yearNum: 2021,
+    yearLabel: "2021",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.6,
+    tags: ["javascript", "astro", "islands", "static-site", "partial-hydration"],
+    wikidataId: "Q110879474"
+  }),
+  // ── Runtimes & platforms ─────────────────────────────────────────────
+  ev4({
+    id: "deno",
+    title: "Deno",
+    description: "Ryan Dahl (original Node.js creator) released Deno \u2014 a secure-by-default TypeScript runtime that fixes Node's design mistakes: no node_modules, web-compatible APIs, built-in TypeScript. Forced Node.js to improve security and embrace web standards.",
+    yearNum: 2018,
+    yearLabel: "2018",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.6,
+    tags: ["javascript", "typescript", "deno", "runtime", "secure"],
+    wikidataId: "Q60316451"
+  }),
+  ev4({
+    id: "bun",
+    title: "Bun",
+    description: "Jarred Sumner built Bun \u2014 a JavaScript runtime, bundler, test runner, and package manager in one, written in Zig. 5-10x faster npm installs, 3x faster test runs. Forced the entire Node.js ecosystem to reckon with performance as a feature.",
+    yearNum: 2021,
+    yearLabel: "2021",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.62,
+    tags: ["javascript", "bun", "runtime", "bundler", "fast", "zig"],
+    wikidataId: "Q117248419"
+  }),
+  // ── Web platform standards ───────────────────────────────────────────
+  ev4({
+    id: "http2",
+    title: "HTTP/2",
+    description: "IETF standardized HTTP/2 \u2014 multiplexed streams, header compression, server push, binary protocol. Eliminated the HTTP/1.1 bottleneck of 6 parallel connections per domain. Enabled modern web performance and was prerequisite for cloud-native HTTP APIs.",
+    yearNum: 2015,
+    yearLabel: "2015",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.66,
+    tags: ["http", "http2", "protocol", "multiplexing", "performance", "networking"],
+    wikidataId: "Q1093323"
+  }),
+  ev4({
+    id: "webassembly",
+    title: "WebAssembly (WASM)",
+    description: "W3C standardized WebAssembly \u2014 a binary instruction format that runs near-native speed in browsers. Ports C/C++/Rust to the web without plugins. Enabled Figma, AutoCAD, and game engines in the browser. Also becoming the universal portable compute target (WASI).",
+    yearNum: 2017,
+    yearLabel: "2017",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.7,
+    tags: ["wasm", "webassembly", "browser", "performance", "portable", "runtime"],
+    wikidataId: "Q27139720"
+  }),
+  ev4({
+    id: "pwa",
+    title: "Progressive Web Apps (PWA)",
+    description: "Google engineer Alex Russell coined PWA \u2014 web apps that use Service Workers, Web App Manifests, and HTTPS to behave like native apps. Offline support, push notifications, home screen install. Closed the gap between web and native without an app store.",
+    yearNum: 2015,
+    yearLabel: "2015",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.62,
+    tags: ["pwa", "service-worker", "offline", "mobile", "web-app"],
+    wikidataId: "Q30433612"
+  }),
+  ev4({
+    id: "service_workers",
+    title: "Service Workers",
+    description: "W3C standardized Service Workers \u2014 JavaScript running as a background proxy between the app and network. Offline caching, push notifications, background sync. The core primitive behind PWAs and the same concept powering edge computing runtimes (Cloudflare Workers).",
+    yearNum: 2014,
+    yearLabel: "2014",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.64,
+    tags: ["service-worker", "offline", "cache", "background", "web-api"],
+    wikidataId: "Q19592788"
+  }),
+  ev4({
+    id: "web_components",
+    title: "Web Components",
+    description: "W3C's suite of browser-native component standards: Custom Elements, Shadow DOM, HTML Templates. Framework-agnostic, built into the browser. Influenced every component model (React, Vue, Angular) even as framework components won the DX war.",
+    yearNum: 2011,
+    yearLabel: "2011",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.58,
+    tags: ["web-components", "custom-elements", "shadow-dom", "browser-native"],
+    wikidataId: "Q19855516"
+  }),
+  // ── Developer tooling ─────────────────────────────────────────────────
+  ev4({
+    id: "electron",
+    title: "Electron",
+    description: "GitHub released Electron \u2014 build cross-platform desktop apps with web technologies (Chromium + Node.js). VS Code, Slack, Discord, Figma (before WASM), and GitHub Desktop are all Electron. Controversial (memory usage) but solved cross-platform desktop for web teams.",
+    yearNum: 2013,
+    yearLabel: "2013",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.68,
+    tags: ["electron", "desktop", "cross-platform", "chromium", "nodejs"],
+    wikidataId: "Q17107723"
+  }),
+  ev4({
+    id: "jest",
+    title: "Jest (JavaScript Testing)",
+    description: "Facebook open-sourced Jest \u2014 zero-config JavaScript test runner with mocking, code coverage, and watch mode built in. Replaced Mocha + Chai + Sinon with a unified API. Became the default testing choice for React and most JS projects.",
+    yearNum: 2014,
+    yearLabel: "2014",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.64,
+    tags: ["javascript", "jest", "testing", "tdd", "mocking"],
+    wikidataId: "Q22012789"
+  }),
+  ev4({
+    id: "eslint",
+    title: "ESLint",
+    description: "Nicholas Zakas built ESLint \u2014 the pluggable JavaScript linter. Catches errors, enforces style, and enables static analysis custom rules. Replaced JSHint/JSLint with a fully extensible plugin system. Standard part of every JS project setup since 2014.",
+    yearNum: 2013,
+    yearLabel: "2013",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.62,
+    tags: ["javascript", "eslint", "linting", "static-analysis", "code-quality"],
+    wikidataId: "Q22001024"
+  }),
+  ev4({
+    id: "prettier",
+    title: "Prettier",
+    description: 'James Long built Prettier \u2014 an opinionated code formatter that ended the "tabs vs spaces" wars by removing the choice entirely. Format on save, one style everywhere. Adopted across JS/TS, CSS, Markdown, and GraphQL. Proved that opinionated tools beat configurability.',
+    yearNum: 2017,
+    yearLabel: "2017",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.6,
+    tags: ["javascript", "prettier", "formatter", "code-style", "dx"],
+    wikidataId: "Q57232682"
+  }),
+  // ── Deployment & edge ─────────────────────────────────────────────────
+  ev4({
+    id: "vercel",
+    title: "Vercel (formerly Zeit)",
+    description: 'Guillermo Rauch built Vercel \u2014 deploy any frontend with one command. Git push \u2192 production URL in seconds. Created the "preview deployment" pattern now standard across Netlify, Cloudflare Pages, and Railway. Also the company that built and maintains Next.js.',
+    yearNum: 2015,
+    yearLabel: "2015",
+    precision: "year",
+    domains: ["technology", "economy"],
+    impactScore: 0.7,
+    tags: ["vercel", "deployment", "frontend", "serverless", "preview", "edge"],
+    wikidataId: "Q70716765"
+  }),
+  ev4({
+    id: "netlify",
+    title: "Netlify",
+    description: "Matt Biilmann built Netlify \u2014 the platform that popularized the JAMstack deployment model. Git-based workflow, CDN-first delivery, serverless functions, form handling. Netlify coined the JAMstack term and proved that frontend-as-infrastructure was a viable business.",
+    yearNum: 2014,
+    yearLabel: "2014",
+    precision: "year",
+    domains: ["technology", "economy"],
+    impactScore: 0.66,
+    tags: ["netlify", "jamstack", "deployment", "cdn", "serverless", "frontend"],
+    wikidataId: "Q28027017"
+  }),
+  ev4({
+    id: "jamstack",
+    title: "JAMstack Architecture",
+    description: "JavaScript + APIs + Markup \u2014 the architecture pattern for pre-rendered sites served from CDN edges with dynamic functionality via APIs. Eliminated the origin server for content sites, enabling 100ms global response times. Shaped how the web industry thinks about the frontend/backend split.",
+    yearNum: 2015,
+    yearLabel: "2015",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.64,
+    tags: ["jamstack", "static-site", "cdn", "architecture", "frontend"],
+    wikidataId: "Q65079286"
+  }),
+  ev4({
+    id: "react_native",
+    title: "React Native",
+    description: `Facebook open-sourced React Native \u2014 write React components that render to native iOS and Android UI. "Learn once, write anywhere." Enabled web developers to ship mobile apps, created the cross-platform mobile category, and forced Flutter's creation as a competitor.`,
+    yearNum: 2015,
+    yearLabel: "2015",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.72,
+    tags: ["react", "mobile", "ios", "android", "cross-platform", "native"],
+    wikidataId: "Q19780481"
+  }),
+  ev4({
+    id: "storybook",
+    title: "Storybook",
+    description: 'Storybook introduced isolated component development \u2014 build, test, and document UI components in isolation. The "component-driven development" workflow. Standard in design systems at Airbnb, IBM, BBC, and thousands of teams. Bridged the designer-developer gap.',
+    yearNum: 2016,
+    yearLabel: "2016",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.6,
+    tags: ["storybook", "component", "design-system", "ui", "documentation", "dx"],
+    wikidataId: "Q56059861"
+  })
+];
+
+// ../../packages/ckg/dist/seed/links-web-ecosystem.js
+var seed4 = (fromEvent, toEvent, rel, evidence, confidence) => ({
+  id: `${fromEvent}--${rel}-->${toEvent}`,
+  fromEvent,
+  toEvent,
+  relationship: rel,
+  confidence: confidence ?? (rel === "caused" ? 0.9 : 0.8),
+  evidence,
+  sources: [{ type: "demo-seed", reliability: 0.9, citation: "Causari curated baseline \u2014 web ecosystem" }],
+  contributedBy: "system",
+  validated: true,
+  scope: "world"
+});
+var webEcosystemLinks = [
+  // ── CSS & styling chain ──────────────────────────────────────────────
+  seed4("sass", "bootstrap", "enabled", "Bootstrap 2 adopted Sass as its preprocessor. Sass's variables/mixins made a large CSS framework maintainable. No Sass \u2192 Bootstrap would have been unmaintainable at its scale."),
+  seed4("bootstrap", "tailwind", "inspired", "Tailwind was a direct reaction to Bootstrap's opinion problem \u2014 you always end up fighting the framework. Utility-first was the counter-proposal: no defaults, all primitives.", 0.7),
+  seed4("sass", "tailwind", "inspired", "Sass revealed that developers needed abstraction over raw CSS. Tailwind answered differently \u2014 instead of abstraction via syntax, abstract via utility classes.", 0.55),
+  // ── Ajax & jQuery chain ───────────────────────────────────────────────
+  seed4("ajax", "jquery", "enabled", "Ajax created demand for cross-browser async DOM manipulation. jQuery packaged the Ajax pattern (XMLHttpRequest wrapper) plus DOM helpers into a single library that handled browser inconsistencies.", 0.85),
+  seed4("web", "ajax", "caused", "Ajax is an application-layer pattern on top of the web (HTTP + JavaScript). It requires a browser, a server, and XHR \u2014 all web-native. No web \u2192 no Ajax.", 0.92),
+  seed4("ajax", "reactjs", "enabled", "Ajax proved that partial page updates (not full reloads) were the right UX model. React's component model and virtual DOM are the architectural evolution of that insight.", 0.65),
+  seed4("jquery", "angularjs", "enabled", "AngularJS was built by developers who had used jQuery and wanted structure. jQuery handled DOM; AngularJS added MVC on top. Direct generational succession.", 0.75),
+  seed4("jquery", "npm", "accelerated", 'jQuery plugins were the first widely-shared JS packages. The pattern of "find a plugin, add a script tag" created demand for a proper dependency manager.', 0.6),
+  // ── npm & package ecosystem ───────────────────────────────────────────
+  seed4("nodejs", "npm", "caused", "npm was built specifically for Node.js's module system (require()). Node needed a package manager; npm was its package manager from the start.", 0.92),
+  seed4("npm", "webpack", "enabled", "Webpack solves the browser packaging problem that npm's module graph created. You can't load 1000 node_modules files in a browser \u2014 webpack bundles them into assets.", 0.9),
+  seed4("npm", "babel", "enabled", "Babel is distributed through npm and integrates into npm-based build pipelines. The JS tooling ecosystem exists on top of npm.", 0.85),
+  seed4("npm", "eslint", "enabled", "ESLint is installed via npm and runs in npm build scripts. The pluggable linting ecosystem (eslint-config-*, eslint-plugin-*) is built entirely on npm's package system.", 0.85),
+  seed4("npm", "jest", "enabled", "Jest is installed via npm, configured in package.json, and runs as an npm script. The JS testing ecosystem is npm-native.", 0.85),
+  seed4("npm", "vite", "enabled", 'Vite uses npm/pnpm/bun for dependency management and its plugin ecosystem. The "npm install vite" onboarding is core to its zero-config pitch.', 0.82),
+  seed4("npm", "storybook", "enabled", "Storybook is installed via npm (npx storybook init) and extends the same project's package.json. The entire component documentation ecosystem runs on npm.", 0.82),
+  // ── JS transpiler & bundler chain ────────────────────────────────────
+  seed4("webpack", "babel", "accelerated", `Babel integrates into Webpack via babel-loader. Webpack's dominance made Babel the de facto JS compiler \u2014 "webpack + babel" was the standard SPA setup 2015-2020.`, 0.8),
+  seed4("babel", "reactjs", "enabled", "React's JSX syntax requires Babel to compile. Without @babel/plugin-transform-react-jsx, JSX is a syntax error. Babel made React's unconventional syntax universally deployable.", 0.9),
+  seed4("babel", "angularjs", "enabled", "Angular 2 adopted TypeScript/Babel for decorators and class syntax. The ability to use next-gen JS syntax in 2016 browsers was Babel's enabling contribution.", 0.7),
+  seed4("webpack", "nextjs", "enabled", "Next.js's build system was Webpack-based until v13. Zero-config Webpack is Next.js's core value \u2014 it manages the complex Webpack config you'd otherwise need to write.", 0.85),
+  seed4("vite", "esbuild", "caused", "Vite uses esbuild internally for dependency pre-bundling and TypeScript transpilation. Vite popularized esbuild's approach and drove esbuild adoption.", 0.8),
+  seed4("esbuild", "vite", "enabled", "esbuild's 100x speed improvement over JS-based tools is what makes Vite's near-instant dev server possible. No esbuild \u2192 no Vite dev server speed story.", 0.88),
+  seed4("golang", "esbuild", "caused", "esbuild is written in Go. Its speed advantage comes entirely from Go's parallel processing and native compilation \u2014 JS tooling written in JS can't match it.", 0.88),
+  seed4("vite", "sveltekit", "enabled", "SvelteKit uses Vite as its build foundation. Svelte's Vite plugin handles the compile step; SvelteKit inherited Vite's fast HMR and build performance.", 0.88),
+  seed4("webpack", "vite", "inspired", "Vite was explicitly created to solve Webpack's slow dev-server problem. Every Vite design decision (ESM-first, no bundling in dev) is a reaction to Webpack's bundling-first approach.", 0.8),
+  // ── Framework chain ───────────────────────────────────────────────────
+  seed4("angularjs", "reactjs", "inspired", "React was built at Facebook as a reaction to AngularJS. Facebook tried Angular, found two-way binding caused too many bugs at scale, and built one-way data flow + virtual DOM as the alternative.", 0.75),
+  seed4("angularjs", "vuejs", "inspired", `Evan You worked with AngularJS at Google and wanted a lighter version. Vue took AngularJS's template syntax and two-way binding but removed the complexity. "Angular but approachable."`, 0.82),
+  seed4("angularjs", "angular2", "caused", "Angular 2 is a complete rewrite of AngularJS. The causal link is the brand + team continuity. AngularJS's success justified Google investing in the rewrite.", 0.88),
+  seed4("typescript", "angular2", "caused", "Angular 2 was built in TypeScript from the ground up. Microsoft and Google co-designed Angular 2 with TypeScript as a first-class citizen. No TypeScript \u2192 Angular 2 would look completely different.", 0.88),
+  seed4("reactjs", "nextjs", "caused", "Next.js is a React framework \u2014 it requires React as its rendering layer. No React \u2192 no Next.js.", 0.95),
+  seed4("reactjs", "redux", "caused", "Redux was created to solve React's component state sharing problem. The Flux architecture (Facebook's internal React state solution) directly inspired Redux.", 0.88),
+  seed4("reactjs", "react_native", "caused", "React Native is React rendered to native mobile UI instead of DOM. The component model, JSX, and hooks are identical. No React \u2192 no React Native.", 0.95),
+  seed4("reactjs", "remix", "caused", "Remix is a React framework. Ryan Florence was a core React Router author \u2014 Remix is the evolution of React Router into a full-stack framework.", 0.92),
+  seed4("reactjs", "storybook", "enabled", "Storybook was originally created for React components. The component-as-function model (React) made isolated component stories natural. React's component ecosystem drove Storybook adoption.", 0.82),
+  seed4("vuejs", "vite", "caused", `Vite was created by Evan You, Vue's author, to solve Vue's build performance problems. Vite started as "Vue 3's build tool" before expanding to support all frameworks.`, 0.9),
+  seed4("vuejs", "sveltekit", "inspired", "SvelteKit's design (file-based routing, adapter pattern) was influenced by Nuxt.js (Vue's meta-framework), which preceded SvelteKit.", 0.55),
+  seed4("svelte", "sveltekit", "caused", "SvelteKit is Svelte's official meta-framework. Same relationship as React\u2192Next.js or Vue\u2192Nuxt.", 0.95),
+  seed4("reactjs", "astro", "enabled", "Astro was built to work with React (and Vue, Svelte) components as islands. The component model React popularized is what Astro's island architecture imports selectively.", 0.75),
+  // ── Runtimes chain ────────────────────────────────────────────────────
+  seed4("nodejs", "deno", "caused", 'Deno was built by Ryan Dahl as a correction of Node.js design mistakes (package.json, node_modules, no default security). Deno requires Node.js to have existed as the "what we learned from."', 0.92),
+  seed4("nodejs", "bun", "inspired", "Bun was created explicitly to replace Node.js with a faster, all-in-one alternative. Every Bun API is a faster drop-in replacement for a Node.js API. Node had to exist as the target.", 0.88),
+  seed4("typescript", "deno", "caused", "Deno supports TypeScript natively without a compilation step. TypeScript-first was a core design decision \u2014 deno replaced babel/tsc in the workflow.", 0.85),
+  seed4("deno", "bun", "inspired", "Bun saw Deno's TypeScript-first, no-node_modules approach and pushed further on performance. Bun uses Zig instead of Rust/V8 to extract maximum speed.", 0.65),
+  // ── Web platform standards chain ─────────────────────────────────────
+  seed4("service_workers", "pwa", "caused", "Service Workers are the core enabling technology of PWAs. Offline caching, push notifications, background sync \u2014 all implemented via Service Workers. No Service Workers \u2192 no meaningful PWA.", 0.92),
+  seed4("http2", "pwa", "enabled", "HTTP/2 server push and multiplexing make PWA asset loading efficient. PWA performance targets require HTTP/2 to be achievable.", 0.65),
+  seed4("web", "service_workers", "enabled", "Service Workers extend the web platform with a programmable network layer. They require HTTPS (web security model) and browser APIs. Web platform is the prerequisite.", 0.85),
+  seed4("web", "web_components", "caused", "Web Components are a native web platform specification \u2014 they exist to give the web its own component model independent of JS frameworks.", 0.88),
+  seed4("web_components", "reactjs", "inspired", "React's component model was in part inspired by the Web Components specification being developed around the same time. Both solved the same problem \u2014 React won the DX battle.", 0.55),
+  seed4("service_workers", "cloudflare_workers", "inspired", "Cloudflare Workers were directly inspired by the Service Worker API. Same event-driven model, same fetch interception pattern \u2014 moved to the edge instead of the browser.", 0.85),
+  // ── WASM chain ────────────────────────────────────────────────────────
+  seed4("javascript", "webassembly", "enabled", "WASM runs alongside JavaScript in the browser \u2014 they share the same runtime, call each other's APIs, and compile to the same memory model. JS proved the browser was a viable runtime; WASM extended it.", 0.75),
+  seed4("webassembly", "astro", "enabled", "Astro uses WASM internally for its build pipeline (Rollup WASM plugin, the compiler itself was ported to WASM). WASM enables fast native-speed build tools in a browser-compatible format.", 0.55),
+  seed4("rust_1_0", "webassembly", "enabled", "Rust is the dominant WASM compilation target \u2014 wasm-pack, wasm-bindgen make Rust\u2192WASM ergonomic. WASM's systems-programming use cases overwhelmingly use Rust.", 0.82),
+  // ── Developer tooling chain ───────────────────────────────────────────
+  seed4("nodejs", "electron", "caused", "Electron embeds Node.js for system access in desktop apps. Electron = Chromium + Node.js. No Node.js \u2192 no Electron.", 0.95),
+  seed4("github", "electron", "caused", "GitHub created Electron to build the GitHub Desktop app and the Atom editor. The company that built Electron is GitHub. Direct organizational causation.", 0.92),
+  seed4("electron", "vscode", "caused", "VS Code is built on Electron. Microsoft chose Electron specifically to enable a cross-platform editor written in TypeScript/JavaScript.", 0.95),
+  seed4("vscode", "prettier", "accelerated", `VS Code's "format on save" feature + Prettier integration (prettier-vscode extension, 38M downloads) made Prettier adoption mainstream. Without VS Code, Prettier would have stayed a CLI tool.`, 0.82),
+  seed4("vscode", "eslint", "accelerated", "VS Code's ESLint extension surfaces lint errors inline as you type. Real-time feedback transformed ESLint from a CI gate to an interactive coding assistant.", 0.78),
+  seed4("babel", "jest", "enabled", "Jest uses Babel (or ts-jest) to transform modern JS/TS syntax before running tests. The ability to test JSX and ES modules depends on Babel's transform pipeline.", 0.82),
+  seed4("reactjs", "jest", "accelerated", "Facebook built Jest specifically for testing React components. The React ecosystem drove Jest adoption \u2014 React devs needed to test components, and Jest was the answer.", 0.8),
+  seed4("eslint", "prettier", "enabled", "Prettier and ESLint were designed to coexist via eslint-config-prettier (disables formatting rules). ESLint handles code quality; Prettier handles formatting. The ecosystem defined both roles.", 0.72),
+  // ── Deployment chain ──────────────────────────────────────────────────
+  seed4("aws", "netlify", "enabled", "Netlify runs on AWS infrastructure (S3, CloudFront, Lambda). The cloud primitive layer (object storage + CDN + serverless functions) is what Netlify packages into a developer-friendly UI.", 0.75),
+  seed4("aws", "vercel", "enabled", "Vercel runs on AWS (and other clouds). Same enabling relationship as AWS \u2192 Netlify. Cloud primitives \u2192 developer experience layer.", 0.72),
+  seed4("netlify", "jamstack", "caused", "Matt Biilmann (Netlify CEO) coined the JAMstack term and Netlify embodies the pattern. JAMstack is the architecture that Netlify was built to serve.", 0.88),
+  seed4("jamstack", "nextjs", "accelerated", "Next.js's static generation mode (getStaticProps) is JAMstack-compatible. The JAMstack ecosystem created demand for React frameworks that could pre-render pages, which Next.js served.", 0.72),
+  seed4("github", "netlify", "enabled", `Netlify's core UX is "connect a GitHub repo, get a deployment." Without GitHub's API and webhook infrastructure, Netlify's git-based workflow doesn't exist.`, 0.88),
+  seed4("github", "vercel", "enabled", "Vercel's git-based deployment (preview per PR, production on merge) requires GitHub integration. The GitHub PR + preview deployment pattern is Vercel's core product.", 0.88),
+  seed4("netlify", "vercel", "accelerated", "Vercel (launched 2015) was directly inspired by and competed with Netlify. Netlify proved the git-based frontend deployment market; Vercel captured it with a Next.js angle.", 0.75),
+  seed4("nextjs", "vercel", "caused", "Vercel creates and maintains Next.js. Next.js is Vercel's distribution vehicle \u2014 every Next.js project is a potential Vercel customer.", 0.88),
+  seed4("reactjs", "vercel", "enabled", "Vercel's success is tied to React's dominance. A major reason to use Vercel is the optimized Next.js hosting. React \u2192 Next.js \u2192 Vercel is the adoption funnel.", 0.72),
+  // ── Mobile chain ──────────────────────────────────────────────────────
+  seed4("react_native", "svelte", "inspired", "Svelte's framework-as-compiler insight was partly inspired by native mobile compilers \u2014 compile to efficient native output rather than shipping a virtual DOM runtime.", 0.4),
+  seed4("pwa", "react_native", "enabled", "PWA and React Native solve adjacent problems (web vs native mobile). PWA's limitations (no deep hardware access) justified React Native's native bridge approach.", 0.55),
+  // ── Storybook / Design systems ────────────────────────────────────────
+  seed4("storybook", "tailwind", "accelerated", "Storybook + Tailwind became the standard design system stack. Component isolation (Storybook) pairs naturally with utility-class styling (Tailwind) \u2014 both enforce reuse and consistency.", 0.62),
+  // ── Cross-era links ───────────────────────────────────────────────────
+  seed4("javascript", "jquery", "caused", "jQuery is a JavaScript library \u2014 it requires JavaScript to exist. jQuery extended JS with cross-browser abstractions that the language itself lacked in 2006.", 0.95),
+  seed4("javascript", "npm", "enabled", "npm is the JavaScript package manager. The entire npm ecosystem exists because JS (via Node.js) needed package distribution. No JS runtime \u2192 no npm.", 0.9),
+  seed4("javascript", "webpack", "caused", "Webpack solves a JavaScript problem: how to use CommonJS/ES modules in a browser that doesn't support them. JS modules \u2192 module bundler demand.", 0.9),
+  seed4("javascript", "babel", "caused", "Babel exists to compile newer JavaScript to older JavaScript. Without JavaScript itself, there is no Babel.", 0.95),
+  seed4("http2", "grpc", "caused", "gRPC is built on HTTP/2 \u2014 it uses HTTP/2 multiplexing, flow control, and header compression. HTTP/2 is the transport layer gRPC requires.", 0.92)
+];
+
+// ../../packages/ckg/dist/seed/events-cloud-devops.js
+var src3 = {
+  type: "demo-seed",
+  reliability: 0.9,
+  citation: "Causari curated baseline \u2014 cloud & devops"
+};
+function ev5(e) {
+  return { ...e, scope: "world", sources: [src3] };
+}
+var cloudDevopsEvents = [
+  // ── Web server & proxy layer ─────────────────────────────────────────
+  ev5({
+    id: "apache_http",
+    title: "Apache HTTP Server",
+    description: 'The Apache HTTP Server (1995) became the dominant web server by running Linux-based hosting. "A patchy server" powered 65% of the web at peak. The first platform for dynamic content via CGI and mod_php \u2014 the A in LAMP stack.',
+    yearNum: 1995,
+    yearLabel: "1995",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.78,
+    tags: ["apache", "web-server", "http", "lamp", "open-source"],
+    wikidataId: "Q11354"
+  }),
+  ev5({
+    id: "nginx",
+    title: "Nginx",
+    description: "Igor Sysoev built Nginx to handle the C10K problem \u2014 10,000 concurrent connections that Apache's process-per-connection model couldn't serve. Event-driven, async, low memory. Now used by 34% of all websites and is the default reverse proxy for every major cloud service.",
+    yearNum: 2004,
+    yearLabel: "2004",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.76,
+    tags: ["nginx", "web-server", "reverse-proxy", "load-balancer", "c10k"],
+    wikidataId: "Q2482243"
+  }),
+  ev5({
+    id: "haproxy",
+    title: "HAProxy",
+    description: "Willy Tarreau released HAProxy \u2014 the high-availability TCP/HTTP load balancer. Used at GitHub, Twitter, Instagram, and Airbnb for routing billions of requests. The invisible infrastructure piece that makes horizontal scaling work.",
+    yearNum: 2001,
+    yearLabel: "2001",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.64,
+    tags: ["haproxy", "load-balancer", "tcp", "proxy", "high-availability"],
+    wikidataId: "Q847059"
+  }),
+  // ── Message queues & streaming ────────────────────────────────────────
+  ev5({
+    id: "rabbitmq",
+    title: "RabbitMQ",
+    description: "Pivotal released RabbitMQ \u2014 the AMQP message broker. Producer-consumer decoupling, durable queues, fanout/routing patterns. Became the standard async messaging layer for microservices before Kafka redefined event streaming.",
+    yearNum: 2007,
+    yearLabel: "2007",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.64,
+    tags: ["rabbitmq", "message-queue", "amqp", "async", "messaging"],
+    wikidataId: "Q1066003"
+  }),
+  ev5({
+    id: "kafka",
+    title: "Apache Kafka",
+    description: "LinkedIn open-sourced Kafka \u2014 distributed event streaming platform. Append-only log, consumer groups, horizontal partitioning. Handles 7 trillion events/day at LinkedIn. Redefined data integration from ETL batch jobs to real-time event streams.",
+    yearNum: 2011,
+    yearLabel: "2011",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.78,
+    tags: ["kafka", "event-streaming", "distributed", "log", "real-time"],
+    wikidataId: "Q16235208"
+  }),
+  ev5({
+    id: "redis",
+    title: "Redis",
+    description: "Salvatore Sanfilippo built Redis \u2014 the in-memory data structure store. Sub-millisecond reads, pub/sub, sorted sets, streams. Used as cache, session store, job queue, leaderboard, and rate limiter. The Swiss Army knife of backend infrastructure.",
+    yearNum: 2009,
+    yearLabel: "2009",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.76,
+    tags: ["redis", "cache", "in-memory", "pub-sub", "database", "key-value"],
+    wikidataId: "Q1153693"
+  }),
+  // ── CI/CD ─────────────────────────────────────────────────────────────
+  ev5({
+    id: "jenkins",
+    title: "Jenkins (CI/CD)",
+    description: "Originally Hudson (Sun Microsystems), Jenkins became the dominant open-source CI server. Plugin ecosystem (1000+), pipeline-as-code (Jenkinsfile), and self-hosted model made it the default automation backbone for enterprise software for a decade.",
+    yearNum: 2011,
+    yearLabel: "2011",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.72,
+    tags: ["jenkins", "ci-cd", "automation", "pipeline", "build"],
+    wikidataId: "Q1454687"
+  }),
+  ev5({
+    id: "gitlab",
+    title: "GitLab",
+    description: 'Dmitriy Zaporozhets built GitLab \u2014 the self-hosted alternative to GitHub. Complete DevOps platform: git hosting + CI/CD + container registry + issue tracking in one. Pioneered the "DevOps platform" category and forced GitHub to ship Actions.',
+    yearNum: 2011,
+    yearLabel: "2011",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.7,
+    tags: ["gitlab", "devops", "ci-cd", "self-hosted", "git"],
+    wikidataId: "Q16457575"
+  }),
+  ev5({
+    id: "github_actions",
+    title: "GitHub Actions",
+    description: "GitHub launched Actions \u2014 CI/CD built directly into GitHub. YAML workflows, reusable actions marketplace, matrix builds. Made CI accessible to every GitHub user without configuring a separate CI tool. Triggered mass migration from Jenkins, CircleCI, and TravisCI.",
+    yearNum: 2018,
+    yearLabel: "2018",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.74,
+    tags: ["github-actions", "ci-cd", "automation", "workflow", "yaml"],
+    wikidataId: "Q65075585"
+  }),
+  // ── Configuration management ──────────────────────────────────────────
+  ev5({
+    id: "ansible",
+    title: "Ansible",
+    description: "Michael DeHaan built Ansible \u2014 agentless infrastructure automation via SSH + YAML playbooks. No daemons to install, no DSL to learn. Made configuration management accessible to sysadmins who weren't Puppet/Chef experts. Red Hat acquired it for $150M.",
+    yearNum: 2012,
+    yearLabel: "2012",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.68,
+    tags: ["ansible", "configuration-management", "automation", "iac", "yaml"],
+    wikidataId: "Q15908534"
+  }),
+  // ── Monitoring & observability ────────────────────────────────────────
+  ev5({
+    id: "prometheus",
+    title: "Prometheus",
+    description: "SoundCloud open-sourced Prometheus \u2014 the pull-based metrics system with PromQL and built-in alerting. Became the CNCF standard for cloud-native monitoring. Kubernetes and every cloud-native project exposes Prometheus metrics. The lingua franca of SRE.",
+    yearNum: 2012,
+    yearLabel: "2012",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.72,
+    tags: ["prometheus", "monitoring", "metrics", "alerting", "promql", "sre"],
+    wikidataId: "Q17156677"
+  }),
+  ev5({
+    id: "grafana",
+    title: "Grafana",
+    description: "Torkel \xD6degaard built Grafana \u2014 the open dashboarding layer for Prometheus, InfluxDB, and every other time-series database. Turned metrics into visual stories. The default observability dashboard for every Kubernetes deployment and cloud infrastructure.",
+    yearNum: 2014,
+    yearLabel: "2014",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.68,
+    tags: ["grafana", "dashboard", "visualization", "monitoring", "observability"],
+    wikidataId: "Q59206168"
+  }),
+  ev5({
+    id: "sentry",
+    title: "Sentry (Error Tracking)",
+    description: 'David Cramer built Sentry \u2014 open-source error tracking that captures exceptions with full stack traces, context, and user data. "npm install @sentry/node" became the first step in any production deployment. Made error observability a default practice.',
+    yearNum: 2008,
+    yearLabel: "2008",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.66,
+    tags: ["sentry", "error-tracking", "observability", "debugging", "apm"],
+    wikidataId: "Q13619910"
+  }),
+  ev5({
+    id: "datadog",
+    title: "Datadog",
+    description: "Olivier Pomel and Alexis L\xEA-Qu\xF4c built Datadog \u2014 cloud-native APM, infrastructure monitoring, log management, and synthetic monitoring in one SaaS platform. $40B market cap. Set the standard for what enterprise observability looks like in the cloud era.",
+    yearNum: 2010,
+    yearLabel: "2010",
+    precision: "year",
+    domains: ["technology", "economy"],
+    impactScore: 0.7,
+    tags: ["datadog", "apm", "monitoring", "observability", "saas"],
+    wikidataId: "Q13599581"
+  }),
+  ev5({
+    id: "opentelemetry",
+    title: "OpenTelemetry",
+    description: 'CNCF merged OpenTracing and OpenCensus into OpenTelemetry \u2014 the vendor-neutral standard for traces, metrics, and logs. One SDK, any backend (Datadog, Honeycomb, Grafana, Jaeger). Ended the observability vendor lock-in era and made the "three pillars" concrete.',
+    yearNum: 2019,
+    yearLabel: "2019",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.68,
+    tags: ["opentelemetry", "otel", "tracing", "observability", "vendor-neutral", "cncf"],
+    wikidataId: "Q87089591"
+  }),
+  // ── Service mesh & networking ─────────────────────────────────────────
+  ev5({
+    id: "grpc",
+    title: "gRPC",
+    description: "Google open-sourced gRPC \u2014 a high-performance RPC framework using Protocol Buffers and HTTP/2. Typed service contracts, streaming, cross-language. Replaced REST for internal microservice communication at Google, Netflix, and Cisco. The backbone of cloud-native service communication.",
+    yearNum: 2015,
+    yearLabel: "2015",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.7,
+    tags: ["grpc", "rpc", "protobuf", "http2", "microservices", "streaming"],
+    wikidataId: "Q29474706"
+  }),
+  ev5({
+    id: "istio",
+    title: "Istio (Service Mesh)",
+    description: "Google, IBM, and Lyft open-sourced Istio \u2014 a service mesh for Kubernetes. mTLS between services, traffic management, observability, circuit breaking \u2014 all without code changes. Proved that cross-cutting operational concerns belong in infrastructure, not application code.",
+    yearNum: 2017,
+    yearLabel: "2017",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.66,
+    tags: ["istio", "service-mesh", "kubernetes", "mtls", "traffic", "envoy"],
+    wikidataId: "Q47444879"
+  }),
+  ev5({
+    id: "envoy_proxy",
+    title: "Envoy Proxy",
+    description: "Lyft open-sourced Envoy \u2014 a high-performance C++ L7 proxy. Observability built in, hot restart, dynamic configuration via xDS API. Became the data plane for Istio, AWS App Mesh, and every major service mesh. The proxy that unified cloud-native networking.",
+    yearNum: 2016,
+    yearLabel: "2016",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.66,
+    tags: ["envoy", "proxy", "service-mesh", "l7", "xds", "sidecar"],
+    wikidataId: "Q61801997"
+  }),
+  // ── Kubernetes ecosystem ──────────────────────────────────────────────
+  ev5({
+    id: "helm",
+    title: "Helm (Kubernetes Package Manager)",
+    description: 'Helm introduced Charts \u2014 the package format for Kubernetes applications. "apt-get for Kubernetes." Template YAML configs, version them, share them. Became the standard way to distribute and deploy Kubernetes applications.',
+    yearNum: 2015,
+    yearLabel: "2015",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.66,
+    tags: ["helm", "kubernetes", "package-manager", "charts", "deployment"],
+    wikidataId: "Q55638993"
+  }),
+  ev5({
+    id: "argocd",
+    title: "Argo CD (GitOps)",
+    description: 'Intuit open-sourced Argo CD \u2014 the GitOps continuous delivery tool for Kubernetes. Git is the source of truth; Argo CD syncs cluster state to match. Mainstreamed GitOps as the operational model for Kubernetes: "everything in Git, cluster matches Git."',
+    yearNum: 2018,
+    yearLabel: "2018",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.66,
+    tags: ["argocd", "gitops", "kubernetes", "continuous-delivery", "declarative"],
+    wikidataId: "Q87105148"
+  }),
+  ev5({
+    id: "etcd",
+    title: "etcd",
+    description: 'CoreOS built etcd \u2014 a distributed key-value store using Raft consensus. Kubernetes uses etcd as its primary data store \u2014 all cluster state (pods, configs, secrets) lives in etcd. The "brain" of every Kubernetes cluster.',
+    yearNum: 2013,
+    yearLabel: "2013",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.66,
+    tags: ["etcd", "distributed", "key-value", "raft", "consensus", "kubernetes"],
+    wikidataId: "Q22012795"
+  }),
+  ev5({
+    id: "containerd",
+    title: "containerd",
+    description: "Docker open-sourced containerd \u2014 the container runtime that manages the container lifecycle (pull, run, stop). Kubernetes dropped Docker in favor of containerd as the CRI-compliant runtime. Now runs every container on every major cloud Kubernetes service.",
+    yearNum: 2016,
+    yearLabel: "2016",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.64,
+    tags: ["containerd", "container-runtime", "cri", "docker", "kubernetes"],
+    wikidataId: "Q43748082"
+  }),
+  // ── Infrastructure as code ────────────────────────────────────────────
+  ev5({
+    id: "pulumi",
+    title: "Pulumi",
+    description: "Pulumi brought IaC to real programming languages \u2014 TypeScript, Python, Go instead of Terraform's HCL. Full language features (loops, functions, testing) for infrastructure. Challenged Terraform's DSL-based approach and grew the IaC market to non-ops engineers.",
+    yearNum: 2018,
+    yearLabel: "2018",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.62,
+    tags: ["pulumi", "iac", "typescript", "infrastructure", "cloud", "declarative"],
+    wikidataId: "Q61804289"
+  }),
+  // ── Security & secrets ────────────────────────────────────────────────
+  ev5({
+    id: "letsencrypt",
+    title: "Let's Encrypt",
+    description: `Internet Security Research Group launched Let's Encrypt \u2014 free, automated TLS certificates. Eliminated the friction and cost of HTTPS. Web went from 30% HTTPS in 2015 to 95%+ by 2023. Made "HTTPS everywhere" a practical reality, not just a recommendation.`,
+    yearNum: 2015,
+    yearLabel: "2015",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.74,
+    tags: ["letsencrypt", "tls", "https", "ssl", "certificate", "security"],
+    wikidataId: "Q22060091"
+  }),
+  ev5({
+    id: "vault",
+    title: "HashiCorp Vault",
+    description: 'HashiCorp built Vault \u2014 secrets management for dynamic infrastructure. Dynamic database credentials, PKI, encryption-as-a-service. Solved the "secret zero" problem: how do you bootstrap credentials securely in a world where servers are ephemeral.',
+    yearNum: 2015,
+    yearLabel: "2015",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.66,
+    tags: ["vault", "secrets", "pki", "security", "hashicorp", "encryption"],
+    wikidataId: "Q27983753"
+  }),
+  ev5({
+    id: "cloudflare",
+    title: "Cloudflare CDN & DDoS Protection",
+    description: "Matthew Prince launched Cloudflare \u2014 CDN, DDoS mitigation, DNS, WAF, and later edge compute, all in one network. Democratized enterprise-grade security for small sites. Protects ~20% of the web by traffic and processes 50M+ HTTP requests per second.",
+    yearNum: 2010,
+    yearLabel: "2010",
+    precision: "year",
+    domains: ["technology", "economy", "systems"],
+    impactScore: 0.74,
+    tags: ["cloudflare", "cdn", "ddos", "dns", "security", "edge"],
+    wikidataId: "Q2139415"
+  }),
+  ev5({
+    id: "cloudflare_workers",
+    title: "Cloudflare Workers (Edge Computing)",
+    description: "Cloudflare launched Workers \u2014 JavaScript running on Cloudflare's edge network (200+ cities), not in a central cloud region. Response latency in milliseconds globally. Pioneered the edge computing model and created a new runtime standard (WinterCG).",
+    yearNum: 2017,
+    yearLabel: "2017",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.7,
+    tags: ["cloudflare-workers", "edge", "serverless", "javascript", "v8", "runtime"],
+    wikidataId: "Q60319975"
+  }),
+  // ── Search & data ─────────────────────────────────────────────────────
+  ev5({
+    id: "elasticsearch",
+    title: "Elasticsearch",
+    description: 'Shay Banon built Elasticsearch \u2014 distributed search and analytics on top of Lucene. Full-text search, aggregations, near-real-time indexing. Became the default for log aggregation (ELK stack), product search, and observability data. The "grep at scale."',
+    yearNum: 2010,
+    yearLabel: "2010",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.7,
+    tags: ["elasticsearch", "search", "distributed", "elk", "logging", "analytics"],
+    wikidataId: "Q3050461"
+  }),
+  // ── Platform / GitOps ─────────────────────────────────────────────────
+  ev5({
+    id: "consul",
+    title: "Consul (Service Discovery)",
+    description: 'HashiCorp released Consul \u2014 service discovery, health checking, and distributed KV. Services register themselves; others discover them by name, not IP. Solved the "which IP is my service?" problem in dynamic cloud infrastructure before Kubernetes DNS made this simpler.',
+    yearNum: 2014,
+    yearLabel: "2014",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.62,
+    tags: ["consul", "service-discovery", "health-check", "hashicorp", "dns"],
+    wikidataId: "Q27983895"
+  }),
+  ev5({
+    id: "github_copilot",
+    title: "GitHub Copilot",
+    description: 'GitHub and OpenAI launched Copilot \u2014 AI pair programming trained on public code. Completes functions, writes tests, suggests implementations in context. First mass-market AI developer tool: 1M+ paid users in 12 months. Redefined what "developer tooling" means.',
+    yearNum: 2021,
+    yearLabel: "2021",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.8,
+    tags: ["copilot", "ai", "coding-assistant", "llm", "developer-tools", "openai"],
+    wikidataId: "Q107561544"
+  }),
+  ev5({
+    id: "pagerduty",
+    title: "PagerDuty",
+    description: `Alex Solomon built PagerDuty \u2014 incident management and on-call scheduling. Integrates with monitoring tools, routes alerts to the right person, tracks incident timelines. Operationalized SRE on-call culture and made "who's on call" a solvable infrastructure problem.`,
+    yearNum: 2009,
+    yearLabel: "2009",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.62,
+    tags: ["pagerduty", "incident-management", "on-call", "alerting", "sre"],
+    wikidataId: "Q7126929"
+  }),
+  ev5({
+    id: "ebpf",
+    title: "eBPF (Extended Berkeley Packet Filter)",
+    description: "Linux kernel developers extended BPF into eBPF \u2014 a programmable kernel subsystem for running sandboxed programs in kernel space. Zero-overhead observability, network filtering, security policy enforcement. Powers Cilium, Falco, and Datadog's lowest-overhead agent.",
+    yearNum: 2014,
+    yearLabel: "2014",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.68,
+    tags: ["ebpf", "linux", "kernel", "observability", "networking", "security"],
+    wikidataId: "Q7956239"
+  })
+];
+
+// ../../packages/ckg/dist/seed/links-cloud-devops.js
+var seed5 = (fromEvent, toEvent, rel, evidence, confidence) => ({
+  id: `${fromEvent}--${rel}-->${toEvent}`,
+  fromEvent,
+  toEvent,
+  relationship: rel,
+  confidence: confidence ?? (rel === "caused" ? 0.9 : 0.8),
+  evidence,
+  sources: [{ type: "demo-seed", reliability: 0.9, citation: "Causari curated baseline \u2014 cloud & devops" }],
+  contributedBy: "system",
+  validated: true,
+  scope: "world"
+});
+var cloudDevopsLinks = [
+  // ── Web server evolution ──────────────────────────────────────────────
+  seed5("linux", "apache_http", "enabled", "Apache runs on Linux and its dominance was inseparable from Linux-based hosting. The LAMP stack (Linux + Apache + MySQL + PHP) defined a decade of web hosting.", 0.88),
+  seed5("apache_http", "nginx", "caused", "Nginx was created specifically to solve Apache's C10K problem. Igor Sysoev observed Apache's process-per-connection model collapse under load and built an event-driven alternative.", 0.92),
+  seed5("nginx", "haproxy", "enabled", "Nginx and HAProxy serve complementary roles \u2014 Nginx as web server/reverse proxy, HAProxy as the TCP/HTTP load balancer in front. The distinction drove both tools to specialize.", 0.65),
+  seed5("linux", "nginx", "enabled", "Nginx is a Linux-native process \u2014 it uses Linux kernel features (epoll, sendfile) for its event-driven performance. Performance numbers are specific to Linux.", 0.85),
+  seed5("nginx", "kubernetes", "enabled", "Nginx Ingress Controller is the most-used Kubernetes ingress. Before Kubernetes had native ingress, Nginx was the standard HTTP proxy layer every Kubernetes cluster needed.", 0.75),
+  seed5("nginx", "cloudflare", "enabled", "Cloudflare's edge network uses Nginx-derived software as its HTTP layer. The event-driven proxy model that Nginx popularized is fundamental to CDN edge architecture.", 0.6),
+  // ── Message queue / streaming chain ───────────────────────────────────
+  seed5("rabbitmq", "kafka", "enabled", "RabbitMQ demonstrated the market for async messaging. LinkedIn built Kafka to handle message volumes RabbitMQ couldn't sustain \u2014 Kafka is an event log, not a message queue, but the demand was proven by RabbitMQ adoption.", 0.6),
+  seed5("kafka", "microservices", "enabled", "Kafka's event streaming model enabled the event-driven microservices pattern. Services publish events to Kafka topics; other services consume them asynchronously \u2014 decoupling that microservices require.", 0.82),
+  seed5("kafka", "elasticsearch", "enabled", "Kafka \u2192 Elasticsearch is a canonical data pipeline: Kafka captures events in real-time; Logstash (or Kafka Connect) streams them to Elasticsearch for indexing and search.", 0.75),
+  seed5("redis", "nosql_movement", "caused", "Redis was one of the founding examples of the NoSQL movement \u2014 a non-relational store optimized for a specific data model (in-memory key-value). It demonstrated that not every problem needs SQL.", 0.8),
+  seed5("redis", "kafka", "enabled", "Redis Streams (added 2018) was influenced by Kafka's log model. Redis provides sub-millisecond Kafka-lite streaming for use cases where Kafka's operational overhead is too high.", 0.55),
+  seed5("nosql_movement", "redis", "enabled", "The NoSQL movement created space for specialized stores like Redis. Once the industry accepted that non-relational was valid for some problems, in-memory KV, document stores, and time-series DB all emerged.", 0.72),
+  // ── CI/CD evolution chain ─────────────────────────────────────────────
+  seed5("agile_manifesto", "jenkins", "enabled", "Agile's continuous integration principle required automation. Jenkins (then Hudson) automated the build \u2192 test \u2192 report cycle that CI demands. The tool existed to operationalize the manifesto's principles.", 0.78),
+  seed5("git", "jenkins", "enabled", "Jenkins triggered builds on git push via webhooks. Git's branching model (feature branches, pull requests) drove the need for per-branch CI that Jenkins provided.", 0.82),
+  seed5("jenkins", "gitlab", "inspired", 'GitLab saw Jenkins as infrastructure separate from source control and embedded CI directly into the git platform. "GitLab CI is Jenkins minus the separate server" was the original pitch.', 0.75),
+  seed5("github", "github_actions", "caused", "GitHub Actions is CI/CD built into GitHub \u2014 not a separate product but a platform feature. GitHub's market position (100M+ developers) made integrated CI the logical next product step.", 0.92),
+  seed5("gitlab", "github_actions", "accelerated", `GitLab's integrated CI/CD proved the market for "git hosting + CI in one platform." GitHub watched GitLab gain enterprise customers and built Actions to compete.`, 0.78),
+  seed5("jenkins", "github_actions", "inspired", "Actions was designed to feel like Jenkins Pipelines but with zero infrastructure management. Every GitHub Actions concept (step, job, artifact) has a Jenkins parallel \u2014 simplified.", 0.65),
+  seed5("github_actions", "argocd", "enabled", "A common GitOps pattern: GitHub Actions pushes image builds to a registry; ArgoCD deploys them to Kubernetes when the manifest changes in Git. Actions handles CI; ArgoCD handles CD.", 0.75),
+  seed5("git", "argocd", "caused", "ArgoCD's core concept \u2014 Git is the source of truth for cluster state \u2014 directly derives from Git's design. No Git branching/merging model \u2192 no GitOps concept.", 0.88),
+  seed5("kubernetes", "argocd", "caused", "ArgoCD is a Kubernetes-native tool \u2014 it runs as controllers inside a Kubernetes cluster and manages Kubernetes resources. No Kubernetes \u2192 no ArgoCD.", 0.92),
+  seed5("kubernetes", "helm", "caused", "Helm was created because raw Kubernetes YAML is unmanageable at scale. Helm solves Kubernetes's own packaging problem \u2014 templated, versioned, shareable YAML bundles.", 0.9),
+  seed5("helm", "argocd", "enabled", "ArgoCD supports Helm as a source format \u2014 it can render Helm charts and sync the output to a cluster. Helm charts became the standard distributable that ArgoCD manages.", 0.78),
+  // ── Observability stack ───────────────────────────────────────────────
+  seed5("kubernetes", "prometheus", "accelerated", "Kubernetes adopted Prometheus as its metrics standard \u2014 every K8s component exposes /metrics in Prometheus format. K8s made Prometheus the default monitoring choice for anyone running containers.", 0.88),
+  seed5("prometheus", "grafana", "enabled", "Grafana was purpose-built to visualize Prometheus data. The prometheus \u2192 grafana pipeline is the canonical observability stack and comes preconfigured in most Kubernetes monitoring setups.", 0.92),
+  seed5("prometheus", "datadog", "accelerated", "Prometheus established the pull-based metrics model and PromQL query standard. Datadog adopted Prometheus exposition format to ingest Prometheus metrics into its SaaS platform.", 0.65),
+  seed5("prometheus", "opentelemetry", "enabled", "OpenTelemetry's metrics specification was designed to be compatible with Prometheus. The Prometheus exposition format is one of OTel's supported output formats, ensuring continuity.", 0.78),
+  seed5("docker", "sentry", "accelerated", "Docker made Sentry deployable on any stack in seconds (docker run sentry). Self-hosting Sentry's error tracking went from complex setup to a single container.", 0.6),
+  seed5("opentelemetry", "datadog", "enabled", 'Datadog supports OpenTelemetry ingestion \u2014 customers instrument with OTel SDKs and ship to Datadog. OTel made Datadog the "open standard backend" rather than a lock-in provider.', 0.72),
+  seed5("opentelemetry", "grafana", "enabled", "Grafana supports OTel natively (Grafana Tempo for traces, Mimir for metrics, Loki for logs). OTel-compatible data flows into Grafana's stack directly.", 0.78),
+  seed5("linux", "ebpf", "caused", `eBPF is a Linux kernel feature \u2014 it requires the Linux kernel's BPF infrastructure. No Linux \u2192 no eBPF. The "extended" in eBPF refers to extensions made to Linux's existing BPF.`, 0.95),
+  seed5("ebpf", "opentelemetry", "enabled", "eBPF enables zero-code instrumentation \u2014 capture traces, metrics, and network data without modifying application code. Combined with OTel, this creates auto-instrumented observability.", 0.72),
+  seed5("ebpf", "kubernetes", "accelerated", "Cilium (eBPF-based Kubernetes networking) replaced iptables with eBPF programs. Kubernetes clusters using Cilium get 40-60% lower network latency and kernel-level observability.", 0.72),
+  seed5("sentry", "opentelemetry", "enabled", "Sentry added OpenTelemetry support \u2014 traces captured by OTel SDKs can feed into Sentry for error-correlated performance monitoring. Error tracking met distributed tracing.", 0.6),
+  // ── Service mesh chain ────────────────────────────────────────────────
+  seed5("kubernetes", "istio", "enabled", "Istio runs as a Kubernetes control plane extension. It requires Kubernetes's pod model, service discovery, and RBAC to function. Istio cannot exist outside Kubernetes.", 0.92),
+  seed5("envoy_proxy", "istio", "caused", "Istio's data plane is entirely Envoy proxies. Envoy sidecars in each pod handle all traffic. Google, IBM, and Lyft (Envoy's creator) co-built Istio on top of Envoy.", 0.92),
+  seed5("microservices", "istio", "enabled", "Istio addresses the cross-cutting concerns of microservices: mTLS between services, distributed tracing, traffic management. The more microservices you run, the more Istio's value compounds.", 0.82),
+  seed5("microservices", "envoy_proxy", "caused", 'Lyft built Envoy to manage its own microservices at scale. The "service mesh" pattern that Envoy enables is inseparable from microservices complexity at hundreds of services.', 0.85),
+  seed5("grpc", "istio", "accelerated", "gRPC is natively supported by Envoy and Istio \u2014 HTTP/2 streaming, service discovery, and load balancing. Istio's traffic management layer works especially well with gRPC's typed contracts.", 0.68),
+  // ── Kubernetes ecosystem ──────────────────────────────────────────────
+  seed5("docker", "containerd", "caused", "containerd was extracted from Docker's codebase as a standalone runtime. Docker split its architecture into containerd (runtime) + Docker Engine (CLI, build). No Docker \u2192 no containerd.", 0.88),
+  seed5("containerd", "kubernetes", "enabled", "Kubernetes deprecated the Docker shim in 1.24 and uses containerd directly via CRI (Container Runtime Interface). containerd IS the K8s runtime on most production clusters today.", 0.88),
+  seed5("linux", "docker", "caused", "Docker uses Linux kernel features: cgroups for resource limits, namespaces for isolation, union filesystems for layers. Docker is Linux kernel features with a good UX. No Linux \u2192 no Docker.", 0.92),
+  seed5("kubernetes", "etcd", "caused", "etcd is Kubernetes's only supported data store. Every Kubernetes cluster requires etcd. The relationship is architectural: K8s controllers read/write to etcd via the API server.", 0.95),
+  seed5("golang", "etcd", "caused", "etcd is written in Go. The Raft implementation, gRPC-based client protocol, and concurrent request handling are all Go-native patterns. Go's concurrency model fit distributed consensus perfectly.", 0.88),
+  seed5("etcd", "consul", "inspired", "etcd and Consul solve overlapping problems (distributed KV, service discovery). Both emerged in 2013-2014 from the same distributed systems moment. HashiCorp saw etcd and built Consul with a richer service-discovery UX.", 0.6),
+  seed5("consul", "vault", "enabled", "HashiCorp built Vault to complement Consul. Consul stores service config; Vault stores secrets. The two tools form a platform: service discovery + secrets management, deployed together.", 0.78),
+  seed5("kubernetes", "vault", "enabled", `Vault Kubernetes auth method allows pods to authenticate using their service account tokens. Kubernetes's RBAC model enabled the "machine identity" that Vault needs to issue dynamic credentials.`, 0.75),
+  // ── Security chain ─────────────────────────────────────────────────────
+  seed5("web", "letsencrypt", "enabled", "Let's Encrypt provides HTTPS certificates for web domains. The web's HTTP protocol is what Let's Encrypt secures. HTTPS is mandatory for HTTP/2, service workers, and secure cookies.", 0.88),
+  seed5("letsencrypt", "pwa", "enabled", "Service Workers (the core PWA technology) require HTTPS. Let's Encrypt made HTTPS free, enabling any developer to deploy a PWA. Before LE, the $100+/year SSL cert was a barrier.", 0.82),
+  seed5("letsencrypt", "cloudflare", "enabled", `Cloudflare integrates Let's Encrypt certificates automatically. The "one-click HTTPS" that Cloudflare offers uses LE as the certificate authority.`, 0.75),
+  seed5("cloudflare", "cloudflare_workers", "caused", "Cloudflare Workers is Cloudflare's compute offering on its existing edge network. The 200+ city PoP infrastructure was already built for CDN; Workers added programmable compute to each PoP.", 0.92),
+  seed5("service_workers", "cloudflare_workers", "inspired", "Cloudflare Workers uses the same event-driven API as browser Service Workers. The fetch event handler pattern was directly borrowed from the Service Worker specification.", 0.85),
+  seed5("cloudflare_workers", "vercel", "accelerated", "Cloudflare Workers demonstrated edge-first deployment; Vercel adopted edge runtimes and edge functions, competing with Cloudflare's edge compute offering. Both accelerated edge adoption.", 0.65),
+  // ── Platform acceleration ─────────────────────────────────────────────
+  seed5("aws", "elasticsearch", "enabled", "AWS launched Amazon OpenSearch (Elasticsearch fork). Cloud-native Elasticsearch became possible because AWS provisioned and managed the complex distributed cluster setup for customers.", 0.72),
+  seed5("aws", "redis", "accelerated", "AWS ElastiCache for Redis made managed Redis available in one click. Self-managed Redis required ops expertise; ElastiCache drove Redis into mainstream backend architecture.", 0.72),
+  seed5("aws", "kafka", "accelerated", "Amazon MSK (Managed Streaming for Kafka) removed Kafka's operational complexity. Managing Kafka at scale is notoriously hard; MSK drove Kafka adoption beyond large organizations.", 0.7),
+  seed5("kubernetes", "pulumi", "enabled", "Pulumi's Kubernetes provider is one of its most-used integrations. Kubernetes YAML templating (Helm's weakness) pushed teams toward Pulumi's real-language approach.", 0.7),
+  seed5("terraform", "pulumi", "inspired", `Pulumi was built as a reaction to Terraform's HCL DSL. "Terraform but in TypeScript" is the one-line pitch. Terraform had to exist and dominate before Pulumi could offer a contrast.`, 0.85),
+  seed5("github", "gitlab", "accelerated", "GitLab grew in part as a reaction to GitHub's acquisition by Microsoft (2018). Enterprises wanting self-hosted, integrated DevOps migrated to GitLab.", 0.65),
+  seed5("pagerduty", "prometheus", "enabled", "Prometheus Alertmanager routes alerts to PagerDuty. The Prometheus \u2192 Alertmanager \u2192 PagerDuty pipeline is the canonical SRE on-call architecture.", 0.72),
+  seed5("prometheus", "pagerduty", "enabled", "Prometheus fires alerts based on PromQL rules; PagerDuty receives them for routing and escalation. Each tool handles its layer: metrics \u2192 alert \u2192 incident management.", 0.72),
+  // ── AI + DevOps intersection ──────────────────────────────────────────
+  seed5("github", "github_copilot", "caused", "GitHub Copilot is a GitHub product \u2014 built on GitHub's corpus of public code, integrated into GitHub's IDE workflow, and sold as a GitHub subscription. No GitHub \u2192 no Copilot.", 0.92),
+  seed5("vscode", "github_copilot", "enabled", "Copilot launched as a VS Code extension. VS Code's 70% market share made it the distribution vehicle for Copilot. The extension API that VS Code provides is what powers inline completions.", 0.88),
+  seed5("chatgpt", "github_copilot", "accelerated", "ChatGPT's December 2022 launch proved to the market that LLMs could code. Copilot adoption accelerated dramatically after ChatGPT \u2014 the market believed in AI coding tools for the first time.", 0.75),
+  seed5("github_copilot", "mcp_protocol", "enabled", "Copilot proved that AI coding tools could be integrated into developer workflows. MCP extends the same concept \u2014 instead of code completion, structured tool calls. Copilot established developer acceptance of AI IDE tools.", 0.65),
+  // ── Cross-vertical links ───────────────────────────────────────────────
+  seed5("kafka", "ai", "enabled", "Kafka's real-time event streams feed ML feature stores and model training pipelines. Event-driven architectures \u2014 Kafka at the center \u2014 power real-time recommendation and fraud detection systems.", 0.65),
+  seed5("redis", "ai", "enabled", "Redis stores ML model caches, session context, and rate limits for LLM API calls. As AI inference became latency-sensitive, Redis's sub-millisecond reads made it essential infrastructure.", 0.6),
+  seed5("grpc", "transformer", "enabled", "Google's internal infrastructure for training Transformers uses gRPC for distributed communication between workers. TensorFlow's distributed training is built on gRPC.", 0.7),
+  seed5("kubernetes", "ai", "enabled", "Kubernetes GPU scheduling (via NVIDIA device plugin) is the standard way to run LLM training and inference at scale. K8s orchestrates the GPU clusters that power cloud AI.", 0.78),
+  seed5("cloudflare_workers", "mcp_protocol", "enabled", "Cloudflare Workers is a deployment target for MCP servers \u2014 run the MCP server at the edge, close to the agent. The edge-native runtime fits MCP's low-latency tool-call model.", 0.6)
+];
+
+// ../../packages/ckg/dist/seed/events-databases.js
+var src4 = { type: "demo-seed", reliability: 0.9, citation: "Causari curated baseline \u2014 databases" };
+var ev6 = (e) => ({ ...e, scope: "world", sources: [src4] });
+var databaseEvents = [
+  ev6({
+    id: "mysql",
+    title: "MySQL",
+    description: "Michael Widenius and David Axmark built MySQL \u2014 the open-source relational database that powered the LAMP stack and the first generation of web startups. Wikipedia, WordPress, and Facebook started on MySQL. Acquired by Sun then Oracle; MariaDB forked to preserve the open-source lineage.",
+    yearNum: 1995,
+    yearLabel: "1995",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.78,
+    tags: ["mysql", "database", "relational", "lamp", "open-source", "sql"],
+    wikidataId: "Q14565"
+  }),
+  ev6({
+    id: "sqlite",
+    title: "SQLite",
+    description: "D. Richard Hipp built SQLite \u2014 a zero-configuration, serverless SQL database in a single file. Runs inside every Android and iOS app, every Chrome browser, every Python installation. The most deployed database engine in the world by installed count.",
+    yearNum: 2e3,
+    yearLabel: "2000",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.74,
+    tags: ["sqlite", "database", "embedded", "serverless", "sql", "mobile"],
+    wikidataId: "Q319417"
+  }),
+  ev6({
+    id: "mongodb",
+    title: "MongoDB",
+    description: 'Dwight Merriman and Eliot Horowitz built MongoDB \u2014 a JSON document database. Schema-less, horizontally scalable, developer-friendly querying. Led the NoSQL wave for web-scale apps. "If your data is JSON, your database should be JSON" \u2014 convinced a generation of Node.js developers.',
+    yearNum: 2009,
+    yearLabel: "2009",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.72,
+    tags: ["mongodb", "nosql", "document", "json", "database", "bson"],
+    wikidataId: "Q1165412"
+  }),
+  ev6({
+    id: "cassandra",
+    title: "Apache Cassandra",
+    description: "Facebook open-sourced Cassandra \u2014 a wide-column distributed database designed for massive scale with no single point of failure. Used at Apple (10+ PB), Netflix, and Instagram. Proves the CAP theorem in production: choose availability + partition tolerance over strong consistency.",
+    yearNum: 2008,
+    yearLabel: "2008",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.7,
+    tags: ["cassandra", "nosql", "distributed", "wide-column", "cap-theorem"],
+    wikidataId: "Q1082089"
+  }),
+  ev6({
+    id: "dynamodb",
+    title: "Amazon DynamoDB",
+    description: `Amazon released DynamoDB \u2014 serverless key-value and document database with single-digit millisecond latency. Pay-per-request pricing, auto-scaling, global tables. Popularized the "managed NoSQL" category and the single-table design pattern. Powers Amazon.com's cart and session at scale.`,
+    yearNum: 2012,
+    yearLabel: "2012",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.72,
+    tags: ["dynamodb", "nosql", "serverless", "aws", "key-value", "managed"],
+    wikidataId: "Q2040449"
+  }),
+  ev6({
+    id: "influxdb",
+    title: "InfluxDB",
+    description: "Paul Dix built InfluxDB \u2014 the open-source time-series database. Optimized for writing and querying timestamped data: metrics, events, IoT sensor readings. The default time-series backend for Prometheus long-term storage and Grafana data sources.",
+    yearNum: 2013,
+    yearLabel: "2013",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.62,
+    tags: ["influxdb", "time-series", "database", "metrics", "iot", "monitoring"],
+    wikidataId: "Q18570252"
+  }),
+  ev6({
+    id: "neo4j",
+    title: "Neo4j (Graph Database)",
+    description: "Emil Eifrem founded Neo4j \u2014 the leading graph database using nodes, relationships, and properties. Cypher query language makes graph traversal natural. Used for fraud detection, recommendation engines, knowledge graphs, and \u2014 notably \u2014 powering knowledge graphs like the CKG.",
+    yearNum: 2007,
+    yearLabel: "2007",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.64,
+    tags: ["neo4j", "graph-database", "cypher", "knowledge-graph", "relationships"],
+    wikidataId: "Q10888882"
+  }),
+  ev6({
+    id: "vitess",
+    title: "Vitess (MySQL Sharding)",
+    description: "YouTube built Vitess \u2014 a database clustering system for MySQL horizontal sharding. Transparent to applications: same SQL, but sharded across hundreds of MySQL instances. PlanetScale commercialized it; now powers YouTube at 99.99% availability.",
+    yearNum: 2010,
+    yearLabel: "2010",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.62,
+    tags: ["vitess", "mysql", "sharding", "distributed", "youtube", "horizontal-scale"],
+    wikidataId: "Q15052889"
+  }),
+  ev6({
+    id: "firebase_rtdb",
+    title: "Firebase Realtime Database",
+    description: 'Firebase launched its real-time database \u2014 JSON synced across all clients via WebSockets in milliseconds. No backend code needed for real-time features. Defined the "serverless app" category and proved that a database could BE the backend for mobile apps. Google acquired Firebase in 2014.',
+    yearNum: 2011,
+    yearLabel: "2011",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.68,
+    tags: ["firebase", "realtime", "nosql", "serverless", "mobile", "google"],
+    wikidataId: "Q17099233"
+  }),
+  ev6({
+    id: "bigquery",
+    title: "Google BigQuery",
+    description: "Google launched BigQuery \u2014 serverless analytics over petabytes of data in seconds. No cluster to manage, SQL interface, pay-per-query. Proved that columnar analytics at cloud scale could be a commodity service and created the modern cloud data warehouse category.",
+    yearNum: 2010,
+    yearLabel: "2010",
+    precision: "year",
+    domains: ["technology", "economy"],
+    impactScore: 0.7,
+    tags: ["bigquery", "analytics", "data-warehouse", "cloud", "sql", "olap"],
+    wikidataId: "Q15087027"
+  }),
+  ev6({
+    id: "snowflake",
+    title: "Snowflake Data Cloud",
+    description: "Bob Muglia and Benoit Dageville built Snowflake \u2014 a cloud-native data warehouse that separated storage and compute. Share live data without copying. Largest software IPO ever ($3.4B in 2020). Made data sharing between organizations a first-class database feature.",
+    yearNum: 2014,
+    yearLabel: "2014",
+    precision: "year",
+    domains: ["technology", "economy"],
+    impactScore: 0.74,
+    tags: ["snowflake", "data-warehouse", "cloud", "analytics", "data-sharing", "olap"],
+    wikidataId: "Q29547026"
+  }),
+  ev6({
+    id: "clickhouse",
+    title: "ClickHouse",
+    description: "Yandex open-sourced ClickHouse \u2014 a column-oriented OLAP database. 100-1000x faster than MySQL for aggregation queries on time-series and event data. Became the analytical database behind Cloudflare, ByteDance, and Uber's metrics pipelines.",
+    yearNum: 2016,
+    yearLabel: "2016",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.66,
+    tags: ["clickhouse", "olap", "column-oriented", "analytics", "fast", "yandex"],
+    wikidataId: "Q55051447"
+  }),
+  ev6({
+    id: "cockroachdb",
+    title: "CockroachDB",
+    description: 'Spencer Kimball built CockroachDB \u2014 distributed SQL that survives node failures like a cockroach. Strong consistency (Raft), horizontal scaling, PostgreSQL-compatible SQL. The first database to make "Google Spanner" properties accessible to startups.',
+    yearNum: 2015,
+    yearLabel: "2015",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.64,
+    tags: ["cockroachdb", "distributed", "sql", "postgresql-compatible", "raft"],
+    wikidataId: "Q22010688"
+  }),
+  ev6({
+    id: "dbt",
+    title: "dbt (Data Build Tool)",
+    description: 'Fishtown Analytics built dbt \u2014 SQL-first data transformation in the warehouse. Software engineering practices for analytics: version control, testing, documentation for SQL pipelines. Transformed "data analyst" into "analytics engineer" and spawned the modern data stack category.',
+    yearNum: 2016,
+    yearLabel: "2016",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.68,
+    tags: ["dbt", "data-transformation", "analytics", "sql", "data-engineering"],
+    wikidataId: "Q104078399"
+  }),
+  ev6({
+    id: "supabase",
+    title: "Supabase",
+    description: "Paul Copplestone built Supabase \u2014 open-source Firebase alternative built on PostgreSQL. Instant REST and GraphQL APIs, real-time subscriptions, auth, and storage. Brought Firebase's developer experience to a relational, open-source database.",
+    yearNum: 2020,
+    yearLabel: "2020",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.66,
+    tags: ["supabase", "postgresql", "open-source", "firebase-alternative", "baas"],
+    wikidataId: "Q107611116"
+  }),
+  ev6({
+    id: "planetscale",
+    title: "PlanetScale",
+    description: "Sam Lambert commercialized Vitess as PlanetScale \u2014 serverless MySQL with branching like Git. Database schema changes without downtime or locking. Brought software engineering workflow concepts (branches, merges, revert) to database schema management.",
+    yearNum: 2018,
+    yearLabel: "2018",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.62,
+    tags: ["planetscale", "mysql", "serverless", "vitess", "schema-branching"],
+    wikidataId: "Q104390699"
+  }),
+  ev6({
+    id: "timescaledb",
+    title: "TimescaleDB",
+    description: 'Timescale extended PostgreSQL with automatic time partitioning and time-series query optimizations. "The power of PostgreSQL with the scale of time-series databases." DevOps teams adopted it as a Prometheus long-term storage backend with full SQL.',
+    yearNum: 2017,
+    yearLabel: "2017",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.6,
+    tags: ["timescaledb", "postgresql", "time-series", "iot", "metrics"],
+    wikidataId: "Q47482765"
+  }),
+  ev6({
+    id: "pinecone",
+    title: "Pinecone (Vector Database)",
+    description: "Edo Liberty founded Pinecone \u2014 the first managed vector database optimized for embedding similarity search. Storing and querying high-dimensional vectors (embeddings) at scale. Became the infrastructure layer for RAG (Retrieval-Augmented Generation) pipelines.",
+    yearNum: 2019,
+    yearLabel: "2019",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.68,
+    tags: ["pinecone", "vector-database", "embeddings", "similarity-search", "rag", "ai"],
+    wikidataId: "Q117524023"
+  }),
+  ev6({
+    id: "pgvector",
+    title: "pgvector",
+    description: 'pgvector added vector similarity search to PostgreSQL \u2014 cosine similarity, L2 distance, inner product over embedding vectors. Teams running Postgres could now do RAG without a separate vector database. Made "Postgres for AI" viable and boosted Supabase and Neon adoption.',
+    yearNum: 2021,
+    yearLabel: "2021",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.66,
+    tags: ["pgvector", "postgresql", "vector", "embeddings", "rag", "similarity-search"],
+    wikidataId: "Q118255003"
+  }),
+  ev6({
+    id: "neon",
+    title: "Neon (Serverless Postgres)",
+    description: "Nikita Shamgunov built Neon \u2014 serverless PostgreSQL that separates compute from storage. Scales to zero when idle, branches like Git, instant provisioning. Became the database backend for Vercel's serverless functions and the default for Next.js developers.",
+    yearNum: 2022,
+    yearLabel: "2022",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.62,
+    tags: ["neon", "postgresql", "serverless", "branching", "edge", "vercel"],
+    wikidataId: "Q117524556"
+  }),
+  ev6({
+    id: "prisma",
+    title: "Prisma ORM",
+    description: "Johannes Schickling built Prisma \u2014 the TypeScript-first ORM with type-safe query builder, schema-first design, and auto-generated migrations. Replaced Sequelize and TypeORM for TypeScript projects. Made database access in Node.js a fully-typed, ergonomic experience.",
+    yearNum: 2019,
+    yearLabel: "2019",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.66,
+    tags: ["prisma", "orm", "typescript", "database", "schema", "type-safe"],
+    wikidataId: "Q60319453"
+  }),
+  ev6({
+    id: "sqlalchemy",
+    title: "SQLAlchemy",
+    description: "Michael Bayer built SQLAlchemy \u2014 the Python ORM that became the standard for database access across Flask, FastAPI, and every Python web framework. Its Core and ORM layers gave Python developers fine-grained control while abstracting SQL across database engines.",
+    yearNum: 2006,
+    yearLabel: "2006",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.64,
+    tags: ["sqlalchemy", "python", "orm", "database", "sql"],
+    wikidataId: "Q1432598"
+  }),
+  ev6({
+    id: "flyway",
+    title: "Flyway (DB Migrations)",
+    description: `Axel Fontaine built Flyway \u2014 version-controlled database migrations in SQL scripts. The simplest database migration tool: numbered SQL files, applied in order, tracked in a schema history table. Introduced the concept of "database as code" for teams that didn't want an ORM.`,
+    yearNum: 2010,
+    yearLabel: "2010",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.6,
+    tags: ["flyway", "migrations", "database", "versioning", "sql"],
+    wikidataId: "Q15052912"
+  }),
+  ev6({
+    id: "drizzle",
+    title: "Drizzle ORM",
+    description: "Drizzle brought a SQL-first, lightweight TypeScript ORM to serverless and edge environments. Type-safe, zero-dependency, works with Cloudflare D1, Neon, PlanetScale. Emerged as the Prisma alternative for edge-first architectures where Prisma's heavy runtime was problematic.",
+    yearNum: 2022,
+    yearLabel: "2022",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.58,
+    tags: ["drizzle", "orm", "typescript", "edge", "serverless", "sql"],
+    wikidataId: "Q117934582"
+  }),
+  ev6({
+    id: "weaviate",
+    title: "Weaviate (Vector Database)",
+    description: "Bob van Luijt built Weaviate \u2014 an open-source vector database with a built-in ML model inferencing layer. Store objects alongside their embeddings; query by meaning, not keywords. A key infrastructure component in the LLM application stack.",
+    yearNum: 2019,
+    yearLabel: "2019",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.62,
+    tags: ["weaviate", "vector-database", "embeddings", "open-source", "semantic-search", "ai"],
+    wikidataId: "Q117523977"
+  })
+];
+
+// ../../packages/ckg/dist/seed/links-databases.js
+var seed6 = (f, t, rel, ev10, conf) => ({
+  id: `${f}--${rel}-->${t}`,
+  fromEvent: f,
+  toEvent: t,
+  relationship: rel,
+  confidence: conf ?? (rel === "caused" ? 0.9 : 0.8),
+  evidence: ev10,
+  sources: [{ type: "demo-seed", reliability: 0.9, citation: "Causari curated baseline \u2014 databases" }],
+  contributedBy: "system",
+  validated: true,
+  scope: "world"
+});
+var databaseLinks = [
+  // ── Relational evolution ──────────────────────────────────────────────
+  seed6("relational_db", "mysql", "caused", "MySQL implements Codd's relational model with a GPL license. It's the direct open-source operationalization of the relational concept, purpose-built for web applications.", 0.88),
+  seed6("relational_db", "sqlite", "caused", "SQLite is a relational database \u2014 it implements SQL, tables, joins, and ACID transactions. The relational model is its entire design foundation.", 0.9),
+  seed6("mysql", "vitess", "caused", "Vitess was built specifically to shard MySQL. YouTube's MySQL installation hit scaling limits; Vitess adds a transparent sharding layer without changing MySQL itself.", 0.92),
+  seed6("vitess", "planetscale", "caused", "PlanetScale is Vitess commercialized. Same team (Sugu Sougoumarane et al.) built PlanetScale as a managed Vitess SaaS with the Git branching workflow for schema changes.", 0.92),
+  seed6("postgresql", "supabase", "caused", "Supabase is PostgreSQL with a developer-friendly layer: REST API via PostgREST, real-time via logical replication, auth via GoTrue. No Postgres \u2192 no Supabase.", 0.95),
+  seed6("postgresql", "timescaledb", "caused", "TimescaleDB is a PostgreSQL extension \u2014 it runs inside Postgres as a foreign data wrapper extension. No PostgreSQL \u2192 no TimescaleDB.", 0.95),
+  seed6("postgresql", "pgvector", "caused", "pgvector is a PostgreSQL extension that adds a VECTOR data type and similarity operators. It exists only inside PostgreSQL's extension ecosystem.", 0.95),
+  seed6("postgresql", "neon", "caused", "Neon is serverless PostgreSQL \u2014 it uses Postgres's WAL protocol and storage API as the foundation, adding compute-storage separation on top.", 0.9),
+  seed6("postgresql", "cockroachdb", "inspired", "CockroachDB chose PostgreSQL-compatible SQL syntax to minimize migration friction. Postgres is the de facto standard SQL dialect for open-source databases.", 0.8),
+  seed6("relational_db", "cockroachdb", "enabled", "CockroachDB brings the relational model (SQL, ACID, joins) to a distributed architecture. The relational model defines what CockroachDB is trying to preserve at scale.", 0.82),
+  // ── NoSQL branch ──────────────────────────────────────────────────────
+  seed6("nosql_movement", "mongodb", "caused", 'MongoDB is one of the flagship NoSQL databases \u2014 JSON documents, no schema, horizontal sharding. It was a central participant in defining what "NoSQL" meant practically.', 0.88),
+  seed6("nosql_movement", "cassandra", "caused", "Cassandra is a NoSQL database \u2014 wide-column, eventually consistent, partition-tolerant. Facebook built it to solve problems that relational DBs couldn't: geo-distributed, always-available write throughput.", 0.88),
+  seed6("nosql_movement", "dynamodb", "caused", `DynamoDB is Amazon's NoSQL offering. Werner Vogels (Amazon CTO) cited the NoSQL movement and the "Dynamo" paper as the intellectual ancestors of DynamoDB.`, 0.85),
+  seed6("nosql_movement", "firebase_rtdb", "caused", "Firebase Realtime Database is a NoSQL JSON tree synced via WebSockets. Its schema-less, document-oriented model is the NoSQL philosophy applied to real-time mobile apps.", 0.82),
+  seed6("javascript", "mongodb", "accelerated", "MongoDB stores BSON (Binary JSON). Node.js developers working with JSON data found MongoDB's model natural \u2014 the same data structure in JS and in the database. MEAN stack (MongoDB + Express + Angular + Node) drove MongoDB adoption.", 0.78),
+  seed6("nodejs", "mongodb", "accelerated", 'Mongoose (the Node MongoDB ODM) made MongoDB the default database for Node.js CRUD apps. The Node ecosystem normalized "JavaScript everywhere including the database format."', 0.75),
+  // ── Cloud analytics ───────────────────────────────────────────────────
+  seed6("aws", "dynamodb", "caused", "DynamoDB is an AWS-native, fully managed service. It doesn't exist outside AWS \u2014 the whole value prop is zero-infrastructure NoSQL inside the AWS ecosystem.", 0.95),
+  seed6("relational_db", "snowflake", "enabled", "Snowflake uses ANSI SQL \u2014 the relational query language \u2014 as its interface. It's an OLAP data warehouse, but the relational model's SQL is what makes it learnable by every analyst.", 0.8),
+  seed6("bigquery", "snowflake", "enabled", 'BigQuery (2010) proved the "serverless cloud data warehouse" concept \u2014 pay-per-query, no cluster management. Snowflake (2014) offered the same paradigm with superior data sharing and multi-cloud.', 0.72),
+  seed6("aws", "bigquery", "accelerated", "AWS's commercial success proved cloud infrastructure as a business model. Google launched BigQuery in 2010 as its answer to AWS Redshift in the data warehouse space.", 0.65),
+  seed6("dbt", "snowflake", "accelerated", 'dbt was purpose-built for SQL-first transformation inside data warehouses like Snowflake and BigQuery. The "modern data stack" is dbt + Snowflake \u2014 each made the other more valuable.', 0.82),
+  seed6("dbt", "bigquery", "accelerated", "Same relationship as dbt \u2192 Snowflake. dbt works natively with BigQuery's SQL dialect and storage model, making BigQuery+dbt a common enterprise analytics stack.", 0.78),
+  seed6("kafka", "snowflake", "enabled", "Kafka \u2192 Snowflake Connector is a production-standard real-time ingestion pattern. Event streams in Kafka land in Snowflake tables for analytical queries \u2014 real-time operational data meets analytical SQL.", 0.72),
+  seed6("kafka", "clickhouse", "enabled", "Kafka is the standard upstream for ClickHouse event ingestion. Real-time click streams, log events, and metrics flow from Kafka into ClickHouse for sub-second aggregations.", 0.78),
+  // ── Time-series / specialized ─────────────────────────────────────────
+  seed6("prometheus", "influxdb", "enabled", "InfluxDB is used as Prometheus's long-term storage backend (via remote write). Prometheus's short-term TSDB is fast but not built for months of retention.", 0.7),
+  seed6("prometheus", "timescaledb", "enabled", "TimescaleDB's Promscale adapter accepts Prometheus remote write and stores metrics in PostgreSQL with full SQL queryability \u2014 a Postgres alternative to InfluxDB for Prometheus long-term storage.", 0.65),
+  seed6("kafka", "influxdb", "enabled", "IoT and operational metric pipelines frequently use Kafka as the transport layer and InfluxDB as the time-series store. Kafka handles the write volume; InfluxDB handles the time-window queries.", 0.65),
+  // ── Vector / AI layer ─────────────────────────────────────────────────
+  seed6("transformer", "pinecone", "caused", "Pinecone exists because of Transformer embeddings. BERT, OpenAI text-embedding-ada-002, and every embedding model produces vectors that need a vector database. No transformers \u2192 no meaningful embedding use case \u2192 no vector DB market.", 0.88),
+  seed6("transformer", "weaviate", "caused", "Same as transformer \u2192 pinecone. Weaviate was purpose-built for semantic search using Transformer-generated embeddings.", 0.88),
+  seed6("transformer", "pgvector", "caused", "pgvector was created in 2021 specifically to store OpenAI and BERT embeddings inside PostgreSQL. The Transformer-powered embedding ecosystem created the demand.", 0.9),
+  seed6("pinecone", "langchain", "enabled", "LangChain's vector store abstraction (Pinecone, Weaviate, Chroma, pgvector) made vector DBs a composable RAG component. Pinecone was LangChain's first and most-documented integration.", 0.78),
+  seed6("pgvector", "supabase", "accelerated", 'Supabase integrated pgvector natively \u2014 "your Postgres instance now does AI." Supabase + pgvector became the default open-source RAG stack for teams already using Supabase.', 0.82),
+  seed6("pgvector", "neon", "accelerated", "Neon added pgvector support, making serverless Postgres with vector search available. Combined with Vercel's edge functions, the Neon + pgvector stack became popular for AI-powered Next.js apps.", 0.75),
+  // ── ORM / tooling chain ───────────────────────────────────────────────
+  seed6("python", "sqlalchemy", "caused", "SQLAlchemy is a Python library \u2014 it requires Python as the host language. The tool exists to make SQL database access Pythonic.", 0.95),
+  seed6("sqlalchemy", "prisma", "inspired", `Prisma was inspired by SQLAlchemy's concept of type-safe database access, but redesigned for TypeScript's type system. "SQLAlchemy but for TypeScript, with migrations included."`, 0.65),
+  seed6("typescript", "prisma", "enabled", "Prisma's core value is type safety \u2014 the Prisma Client is a fully typed TypeScript API. Without TypeScript's type system, Prisma's auto-completion and type inference don't exist.", 0.88),
+  seed6("typescript", "drizzle", "enabled", "Drizzle is TypeScript-first by design \u2014 schema defined in TypeScript, queries return typed results. No TypeScript \u2192 no Drizzle value proposition.", 0.9),
+  seed6("prisma", "drizzle", "inspired", "Drizzle was built as a Prisma alternative for edge environments where Prisma's runtime was too heavy. Every Drizzle design decision is a direct contrast to a Prisma trade-off.", 0.82),
+  seed6("nextjs", "prisma", "accelerated", 'Next.js + Prisma is one of the most-documented full-stack TypeScript patterns. Next.js API routes \u2192 Prisma \u2192 PostgreSQL became the default "build a web app" starting point.', 0.78),
+  seed6("nextjs", "drizzle", "accelerated", "Drizzle's edge-compatibility made it the ORM of choice for Next.js Edge API routes and Vercel Edge Functions, where Prisma's Node.js runtime doesn't work.", 0.75),
+  seed6("relational_db", "flyway", "caused", "Flyway exists to manage relational database schema migrations. The relational model's schema-ful nature (tables, columns, constraints) is what needs versioning and migration.", 0.88),
+  seed6("git", "flyway", "enabled", "Flyway's numbered migration files map naturally to Git commits \u2014 each migration is a versioned, ordered change applied once. Git became the outer version control layer for Flyway migrations.", 0.72),
+  seed6("git", "planetscale", "inspired", `PlanetScale's "database branching" concept directly mirrors Git branching: create a branch, apply schema changes, open a deploy request (pull request), merge. Git's workflow applied to database schemas.`, 0.85),
+  // ── Firebase chain ─────────────────────────────────────────────────────
+  seed6("firebase_rtdb", "firebase", "caused", "Firebase Realtime Database was Firebase's original product. Google acquired Firebase and expanded it into a full platform (Firestore, Auth, Functions, Hosting) \u2014 but the realtime DB is why Firebase existed.", 0.92),
+  seed6("firebase", "supabase", "inspired", `Supabase positioned itself as "the open-source Firebase alternative." Firebase's developer-friendly BaaS experience is the benchmark Supabase was designed to match, using open-source tools.`, 0.88),
+  seed6("nosql_movement", "firebase_rtdb", "enabled", "Firebase's JSON tree is a NoSQL data model. The NoSQL movement's acceptance of schema-less, document-oriented storage validated Firebase's approach to mobile app data.", 0.75),
+  // ── Graph DB chain ────────────────────────────────────────────────────
+  seed6("relational_db", "neo4j", "inspired", "Neo4j was built to handle highly connected data that relational databases model poorly \u2014 many-to-many relationships require expensive JOINs in SQL but are native graph traversals in Neo4j.", 0.8),
+  seed6("neo4j", "transformer", "enabled", "Knowledge graphs (Neo4j) are one input to early NLP and AI systems. Graph-structured knowledge informed reasoning systems before transformers; some transformer pipelines still use graph context as augmentation.", 0.5),
+  // ── Managed cloud acceleration ─────────────────────────────────────────
+  seed6("kubernetes", "cockroachdb", "enabled", "CockroachDB is cloud-native and Kubernetes-ready \u2014 it uses K8s operators for deployment, scaling, and upgrades. Kubernetes's declarative infrastructure model made distributed SQL operationally viable.", 0.75),
+  seed6("kubernetes", "mongodb", "accelerated", "MongoDB Atlas Kubernetes Operator and the Percona Operator made MongoDB a K8s-native workload. Container orchestration removed the primary barrier to self-hosting production MongoDB.", 0.65),
+  seed6("github_copilot", "prisma", "accelerated", "Prisma's schema DSL and typed client are particularly AI-friendly \u2014 Copilot and Cursor can generate valid Prisma schemas and queries from natural language. AI coding tools drove Prisma adoption by reducing the learning curve.", 0.6)
+];
+
+// ../../packages/ckg/dist/seed/events-ai-tooling.js
+var src5 = { type: "demo-seed", reliability: 0.9, citation: "Causari curated baseline \u2014 AI tooling" };
+var ev7 = (e) => ({ ...e, scope: "world", sources: [src5] });
+var aiToolingEvents = [
+  ev7({
+    id: "cuda",
+    title: "CUDA (GPU Computing)",
+    description: "NVIDIA released CUDA \u2014 a parallel computing platform that lets developers program GPUs for general computation. Deep learning is fundamentally CUDA: every major neural network framework (TensorFlow, PyTorch) runs on CUDA. Without CUDA, the deep learning revolution doesn't happen at the speed it did.",
+    yearNum: 2007,
+    yearLabel: "2007",
+    precision: "year",
+    domains: ["technology", "science"],
+    impactScore: 0.88,
+    tags: ["cuda", "gpu", "parallel-computing", "nvidia", "deep-learning", "hardware"],
+    wikidataId: "Q697928"
+  }),
+  ev7({
+    id: "scikit_learn",
+    title: "scikit-learn",
+    description: "David Cournapeau initiated scikit-learn \u2014 the Python machine learning library. Unified API for classification, regression, clustering, dimensionality reduction, model selection, and preprocessing. Made ML accessible to every Python developer and became the entry point for the field.",
+    yearNum: 2007,
+    yearLabel: "2007",
+    precision: "year",
+    domains: ["technology", "science"],
+    impactScore: 0.76,
+    tags: ["scikit-learn", "python", "machine-learning", "sklearn", "data-science"],
+    wikidataId: "Q1992255"
+  }),
+  ev7({
+    id: "keras",
+    title: "Keras",
+    description: "Fran\xE7ois Chollet built Keras \u2014 a high-level neural network API designed for human beings, not machines. Write a neural network in 10 lines. Ran on top of TensorFlow and Theano. Democratized deep learning for researchers and developers who didn't want to write CUDA. Now merged into TensorFlow 2 as tf.keras.",
+    yearNum: 2015,
+    yearLabel: "2015",
+    precision: "year",
+    domains: ["technology", "science"],
+    impactScore: 0.72,
+    tags: ["keras", "deep-learning", "python", "neural-network", "high-level", "tensorflow"],
+    wikidataId: "Q21094516"
+  }),
+  ev7({
+    id: "tensorflow",
+    title: "TensorFlow",
+    description: 'Google Brain open-sourced TensorFlow \u2014 the computation graph framework that brought industrial-scale deep learning to the world. Defined the "define-then-run" paradigm. Runs in production at Gmail, Google Translate, and Google Search. First framework to ship a production-grade ML serving solution.',
+    yearNum: 2015,
+    yearLabel: "2015",
+    precision: "year",
+    domains: ["technology", "science"],
+    impactScore: 0.84,
+    tags: ["tensorflow", "deep-learning", "google", "neural-network", "production", "ml-framework"],
+    wikidataId: "Q22811878"
+  }),
+  ev7({
+    id: "pytorch",
+    title: "PyTorch",
+    description: 'Facebook AI Research open-sourced PyTorch \u2014 dynamic computation graphs ("define-by-run") that feel like normal Python. Researchers loved it: easy to debug, Pythonic, imperative. Became the dominant research framework by 2020 and is now the default for LLM training (GPT-4, LLaMA, Claude were all trained with PyTorch or derivatives).',
+    yearNum: 2016,
+    yearLabel: "2016",
+    precision: "year",
+    domains: ["technology", "science"],
+    impactScore: 0.86,
+    tags: ["pytorch", "deep-learning", "python", "research", "dynamic-graph", "facebook"],
+    wikidataId: "Q39725088"
+  }),
+  ev7({
+    id: "huggingface_hub",
+    title: "Hugging Face Model Hub",
+    description: 'Cl\xE9ment Delangue built the Hugging Face Hub \u2014 the "GitHub for AI models." 500K+ models, 100K+ datasets, public and private. Made sharing pre-trained weights trivial: `from transformers import pipeline`. Became the distribution layer of the open-source AI ecosystem.',
+    yearNum: 2018,
+    yearLabel: "2018",
+    precision: "year",
+    domains: ["technology", "science"],
+    impactScore: 0.8,
+    tags: ["huggingface", "model-hub", "transformers", "open-source", "ai", "nlp"],
+    wikidataId: "Q56337160"
+  }),
+  ev7({
+    id: "transformers_lib",
+    title: "Hugging Face Transformers Library",
+    description: 'Hugging Face\'s `transformers` Python library unified BERT, GPT, T5, and every subsequent model behind one API. `pipeline("sentiment-analysis")` to run state-of-the-art NLP in 3 lines. Lowered the barrier from "paper author" to "any Python developer." The npm of NLP.',
+    yearNum: 2019,
+    yearLabel: "2019",
+    precision: "year",
+    domains: ["technology", "science"],
+    impactScore: 0.78,
+    tags: ["transformers", "huggingface", "nlp", "python", "bert", "gpt", "library"],
+    wikidataId: "Q87133766"
+  }),
+  ev7({
+    id: "openai_api",
+    title: "OpenAI API (GPT-3 API)",
+    description: 'OpenAI released the GPT-3 API in private beta \u2014 the first commercially viable "intelligence as a service." Developers could call LLM intelligence via HTTP without training or hosting models. Created the AI application developer category and triggered a Cambrian explosion of AI-powered products.',
+    yearNum: 2020,
+    yearLabel: "2020",
+    precision: "year",
+    domains: ["technology", "economy"],
+    impactScore: 0.86,
+    tags: ["openai", "gpt-3", "api", "llm", "ai-as-a-service", "nlp"],
+    wikidataId: "Q82069695"
+  }),
+  ev7({
+    id: "stable_diffusion",
+    title: "Stable Diffusion",
+    description: "Stability AI released Stable Diffusion \u2014 an open-source text-to-image diffusion model. First time state-of-the-art image generation ran on a consumer GPU. Triggered an open-source image generation ecosystem (ComfyUI, Automatic1111, LoRA fine-tuning) and forced DALL-E and Midjourney to compete with freely available models.",
+    yearNum: 2022,
+    yearLabel: "2022",
+    precision: "year",
+    domains: ["technology", "culture"],
+    impactScore: 0.8,
+    tags: ["stable-diffusion", "diffusion-model", "image-generation", "open-source", "generative-ai"],
+    wikidataId: "Q114011447"
+  }),
+  ev7({
+    id: "langchain",
+    title: "LangChain",
+    description: "Harrison Chase built LangChain \u2014 the most popular framework for building LLM-powered applications. Chains, agents, tools, memory, retrievers. Defined the vocabulary of AI app development. Despite community criticism for over-abstraction, it onboarded an entire generation of developers to the LLM application paradigm.",
+    yearNum: 2022,
+    yearLabel: "2022",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.74,
+    tags: ["langchain", "llm", "agents", "rag", "framework", "ai-app"],
+    wikidataId: "Q115913573"
+  }),
+  ev7({
+    id: "rag_pattern",
+    title: "RAG (Retrieval-Augmented Generation)",
+    description: "Patrick Lewis at Meta published the RAG paper \u2014 combine a retrieval system with a generator LLM. Fetch relevant documents, feed to LLM as context. Solves hallucination and knowledge cutoff in one pattern. Became the dominant architecture for production LLM applications that need access to private or current data.",
+    yearNum: 2020,
+    yearLabel: "2020",
+    precision: "year",
+    domains: ["technology", "science"],
+    impactScore: 0.8,
+    tags: ["rag", "retrieval-augmented-generation", "llm", "embeddings", "pattern", "grounding"],
+    wikidataId: "Q116956004"
+  }),
+  ev7({
+    id: "wandb",
+    title: "Weights & Biases (W&B)",
+    description: "Lukas Biewald built Weights & Biases \u2014 ML experiment tracking, model versioning, and collaborative visualization. Log hyperparameters, metrics, and model artifacts across training runs. Made reproducibility and collaboration in ML feel like software engineering, not alchemy.",
+    yearNum: 2018,
+    yearLabel: "2018",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.66,
+    tags: ["wandb", "ml-ops", "experiment-tracking", "model-versioning", "mlops"],
+    wikidataId: "Q100213042"
+  }),
+  ev7({
+    id: "mlflow",
+    title: "MLflow",
+    description: "Databricks open-sourced MLflow \u2014 an ML lifecycle management platform. Track experiments, package models, deploy to any platform, manage a model registry. Became the open-source standard for MLOps and was adopted by every major cloud provider as the ML tracking layer.",
+    yearNum: 2018,
+    yearLabel: "2018",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.64,
+    tags: ["mlflow", "mlops", "experiment-tracking", "model-registry", "databricks"],
+    wikidataId: "Q87133521"
+  }),
+  ev7({
+    id: "onnx",
+    title: "ONNX (Open Neural Network Exchange)",
+    description: 'Facebook and Microsoft created ONNX \u2014 an open format for representing ML models. Train in PyTorch, deploy in TensorFlow.js, TensorRT, or CoreML. Solved the "runtime fragmentation" problem: one model format, any inference engine. The interoperability standard for the ML ecosystem.',
+    yearNum: 2017,
+    yearLabel: "2017",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.64,
+    tags: ["onnx", "interoperability", "ml-model", "inference", "export", "standard"],
+    wikidataId: "Q47444991"
+  }),
+  ev7({
+    id: "llama_meta",
+    title: "LLaMA (Meta Open LLM)",
+    description: "Meta released LLaMA \u2014 a family of open-weight large language models. LLaMA 2 was commercially permissive; LLaMA 3 matched GPT-4 class performance in open weights. Triggered the open-source LLM ecosystem: Mistral, Phi, Qwen all followed. Proved competitive open models were achievable.",
+    yearNum: 2023,
+    yearLabel: "2023",
+    precision: "year",
+    domains: ["technology", "science"],
+    impactScore: 0.82,
+    tags: ["llama", "meta", "open-source", "llm", "open-weights", "language-model"],
+    wikidataId: "Q117142038"
+  }),
+  ev7({
+    id: "vllm",
+    title: "vLLM (Fast LLM Inference)",
+    description: "Woosuk Kwon at UC Berkeley built vLLM \u2014 PagedAttention and continuous batching for LLM inference. 24x throughput improvement over naive inference. Made LLM serving economically viable for production workloads. The default serving engine behind most LLM APIs.",
+    yearNum: 2023,
+    yearLabel: "2023",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.72,
+    tags: ["vllm", "inference", "llm-serving", "throughput", "gpu", "paged-attention"],
+    wikidataId: "Q122238505"
+  }),
+  ev7({
+    id: "ollama",
+    title: "Ollama (Local LLM Runner)",
+    description: "Ollama made running LLMs locally as easy as `ollama run llama3`. One command to download and serve any open-weight model. GPU/CPU inference, OpenAI-compatible API, and a library of 100+ models. Brought LLM capability to every developer's laptop without cloud dependencies.",
+    yearNum: 2023,
+    yearLabel: "2023",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.7,
+    tags: ["ollama", "local-llm", "inference", "developer-tools", "privacy", "open-source"],
+    wikidataId: "Q123474793"
+  }),
+  ev7({
+    id: "cursor_ide",
+    title: "Cursor (AI Code Editor)",
+    description: 'Anysphere built Cursor \u2014 the AI-first code editor (VS Code fork with deep LLM integration). Multi-file edit, codebase-aware chat, automatic context retrieval. Grew to $200M ARR in 2 years. Sparked a category of AI-native editors (Windsurf, Zed, Continue.dev) and forced GitHub Copilot to add "Edits" mode.',
+    yearNum: 2023,
+    yearLabel: "2023",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.76,
+    tags: ["cursor", "ai-editor", "llm", "coding-assistant", "vscode", "agentic"],
+    wikidataId: "Q122882773"
+  }),
+  ev7({
+    id: "ray",
+    title: "Ray (Distributed ML)",
+    description: "Robert Nishihara at UC Berkeley built Ray \u2014 a distributed computing framework for ML workloads. Parallelize any Python function across a cluster with one decorator. Powers model training at OpenAI, Spotify, and Instacart. Foundation of the Anyscale platform and the modern ML infrastructure stack.",
+    yearNum: 2017,
+    yearLabel: "2017",
+    precision: "year",
+    domains: ["technology", "science"],
+    impactScore: 0.66,
+    tags: ["ray", "distributed", "ml-infrastructure", "python", "parallel", "training"],
+    wikidataId: "Q59206178"
+  }),
+  ev7({
+    id: "whisper",
+    title: "Whisper (OpenAI ASR)",
+    description: "OpenAI released Whisper \u2014 a general-purpose speech recognition model trained on 680K hours of multilingual audio. Open-sourced weights. Near-human accuracy in English, usable accuracy in 99 languages. Replaced paid ASR APIs for most applications and enabled transcription-as-default in AI applications.",
+    yearNum: 2022,
+    yearLabel: "2022",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.7,
+    tags: ["whisper", "speech-recognition", "asr", "openai", "open-source", "audio"],
+    wikidataId: "Q114726117"
+  })
+];
+
+// ../../packages/ckg/dist/seed/links-ai-tooling.js
+var seed7 = (f, t, rel, ev10, conf) => ({
+  id: `${f}--${rel}-->${t}`,
+  fromEvent: f,
+  toEvent: t,
+  relationship: rel,
+  confidence: conf ?? (rel === "caused" ? 0.9 : 0.8),
+  evidence: ev10,
+  sources: [{ type: "demo-seed", reliability: 0.9, citation: "Causari curated baseline \u2014 AI tooling" }],
+  contributedBy: "system",
+  validated: true,
+  scope: "world"
+});
+var aiToolingLinks = [
+  // ── GPU computing foundation ──────────────────────────────────────────
+  seed7("cuda", "alexnet", "caused", "AlexNet was trained on two NVIDIA GTX 580 GPUs using CUDA. The 2012 ImageNet win was only possible because CUDA made GPU-accelerated matrix operations available to researchers. No CUDA \u2192 no AlexNet training in weeks, only in years.", 0.95),
+  seed7("cuda", "tensorflow", "enabled", "TensorFlow uses CUDA for GPU acceleration. Every TF operation that runs on GPU invokes CUDA kernels. Without CUDA, TensorFlow runs CPU-only \u2014 orders of magnitude slower.", 0.92),
+  seed7("cuda", "pytorch", "enabled", "PyTorch's entire GPU backend is CUDA. `tensor.cuda()` calls into CUDA kernels. No CUDA \u2192 PyTorch is a slow CPU-only library.", 0.92),
+  seed7("linux", "cuda", "enabled", "CUDA requires Linux for production ML workloads \u2014 NVIDIA's CUDA drivers are Linux-first, NCCL (multi-GPU communication) requires Linux, and all major ML training clusters run Linux.", 0.82),
+  seed7("moores_law", "cuda", "enabled", "CUDA became powerful enough to matter because GPU transistor counts followed Moore's Law. A 2007-era GPU had enough compute to make CUDA useful but not transformative; 2022 GPUs (H100) made it civilization-altering.", 0.78),
+  // ── Framework chain ────────────────────────────────────────────────────
+  seed7("python", "scikit_learn", "caused", "scikit-learn is a Python library \u2014 it requires Python as its host. Python's scientific computing ecosystem (NumPy, SciPy) provided the numerical foundation scikit-learn builds on.", 0.95),
+  seed7("scikit_learn", "keras", "enabled", `scikit-learn established the "fit/transform/predict" API pattern that Keras and PyTorch adopted. The ergonomic ML API design that made DL accessible was informed by scikit-learn's usability work.`, 0.7),
+  seed7("scikit_learn", "tensorflow", "enabled", `TensorFlow's high-level APIs (Estimators, then Keras) were influenced by scikit-learn's unified interface. The goal was "ML accessible to everyone" that scikit-learn proved was achievable.`, 0.65),
+  seed7("tensorflow", "keras", "enabled", "Keras was designed to run on top of TensorFlow (and Theano). TensorFlow is the computation backend; Keras is the ergonomic API layer. In 2019, Keras was merged into TensorFlow 2 as tf.keras.", 0.88),
+  seed7("tensorflow", "pytorch", "inspired", `PyTorch was built as a reaction to TensorFlow's "define-and-run" graph paradigm, which made debugging painful. PyTorch's "define-by-run" dynamic graphs are the anti-TensorFlow design decision.`, 0.82),
+  seed7("pytorch", "tensorflow", "accelerated", "PyTorch's research adoption forced TensorFlow to add eager execution (TF 2.0) and JAX. Competition from PyTorch made TensorFlow significantly better for researchers.", 0.78),
+  seed7("transformer", "tensorflow", "accelerated", "The Transformer paper was implemented in TensorFlow (the dominant 2017 framework). TensorFlow's adoption accelerated the operationalization of Transformer models in production.", 0.72),
+  seed7("transformer", "pytorch", "accelerated", "PyTorch became the dominant framework for Transformer research and LLM training. GPT-2, GPT-3, LLaMA, and most SOTA models were trained in PyTorch. The Transformer era is the PyTorch era.", 0.88),
+  seed7("bert", "huggingface_hub", "caused", `BERT's release as open weights was the founding use case for Hugging Face. The Transformers library started as "easy BERT inference" and expanded from there.`, 0.88),
+  seed7("bert", "transformers_lib", "caused", "Hugging Face's `transformers` library was built to make BERT accessible. BERT was the first Transformer model with a widely used implementation in the HF library.", 0.9),
+  seed7("transformer", "transformers_lib", "enabled", "The Transformers library is named after the architecture. Every model it hosts (BERT, GPT, T5, Llama) is a Transformer variant. The architecture is the library's organizing principle.", 0.92),
+  seed7("huggingface_hub", "transformers_lib", "caused", 'The Hub is the distribution platform for the models that transformers library loads. `model = AutoModel.from_pretrained("bert-base-uncased")` downloads from the Hub. Hub + Library are one ecosystem.', 0.92),
+  // ── LLM API era ───────────────────────────────────────────────────────
+  seed7("gpt3", "openai_api", "caused", "The OpenAI API was built to monetize GPT-3. The API is the commercial interface to the model. No GPT-3 \u2192 no OpenAI API as we know it.", 0.95),
+  seed7("openai_api", "langchain", "caused", "LangChain was created to orchestrate OpenAI API calls. Harrison Chase built it to chain GPT-3 calls with tools and memory. No OpenAI API \u2192 no original LangChain use case.", 0.9),
+  seed7("openai_api", "chatgpt", "enabled", "ChatGPT is a product interface built on top of the same OpenAI API infrastructure. The API capability (GPT-3.5-turbo) became the ChatGPT product.", 0.85),
+  seed7("chatgpt", "langchain", "accelerated", "ChatGPT's December 2022 launch brought millions of developers to LLM application development. LangChain's GitHub stars went from ~1K to 50K in 3 months.", 0.88),
+  seed7("chatgpt", "cursor_ide", "enabled", "ChatGPT demonstrated that LLMs could engage in extended coding conversations. Cursor took that conversation interface and embedded it into the code editor with codebase context.", 0.82),
+  seed7("langchain", "rag_pattern", "accelerated", "LangChain popularized RAG by making it a first-class workflow (RetrievalQA, ConversationalRetrievalChain). The pattern existed in the literature; LangChain made it a 10-line implementation.", 0.82),
+  seed7("transformer", "rag_pattern", "caused", "RAG uses Transformer embeddings for document retrieval and a Transformer LLM for generation. Without the Transformer architecture on both sides, RAG doesn't work.", 0.9),
+  seed7("rag_pattern", "pinecone", "caused", `Pinecone was purpose-built for RAG. The company's pitch was "the vector database for LLM applications" \u2014 retrieval in RAG is the core use case.`, 0.88),
+  seed7("rag_pattern", "langchain", "accelerated", "RAG is LangChain's primary use case. The framework's retriever abstraction and chain composition were designed around the RAG pattern.", 0.82),
+  seed7("openai_api", "stable_diffusion", "inspired", "OpenAI's DALL-E (February 2021) proved text-to-image was a viable API product. Stable Diffusion (open-source) was the community's response: replicate that capability, make it accessible to everyone without an API key.", 0.72),
+  seed7("dalle", "stable_diffusion", "inspired", "DALL-E demonstrated the image generation capability. Stable Diffusion was Stability AI's open-source answer: same quality, runnable on your GPU, no per-image pricing.", 0.82),
+  // ── MLOps chain ───────────────────────────────────────────────────────
+  seed7("kubernetes", "mlflow", "enabled", "MLflow runs well on Kubernetes for multi-user, multi-project ML experiment tracking. K8s provides the isolation and resource management that production MLflow deployments need.", 0.68),
+  seed7("kubernetes", "ray", "enabled", "Ray can run on Kubernetes (KubeRay operator). Kubernetes provides the cluster management; Ray provides the distributed ML scheduler on top.", 0.78),
+  seed7("pytorch", "wandb", "accelerated", "W&B's tightest integration is with PyTorch. `wandb.watch(model)` hooks into PyTorch's autograd to capture gradients and parameter histograms. The PyTorch research community drove W&B adoption.", 0.78),
+  seed7("tensorflow", "mlflow", "enabled", "MLflow's TensorFlow integration automatically logs metrics from tf.keras training loops. The `mlflow.tensorflow.autolog()` function makes MLflow zero-config for TensorFlow users.", 0.72),
+  seed7("pytorch", "mlflow", "enabled", "MLflow's PyTorch integration logs training metrics, saves PyTorch model artifacts, and provides the model registry for deployment. Same enabling relationship as TF \u2192 MLflow.", 0.72),
+  seed7("pytorch", "onnx", "enabled", "PyTorch has native ONNX export (`torch.onnx.export()`). PyTorch is the dominant source format for ONNX models \u2014 most ONNX conversion pipelines start from PyTorch.", 0.88),
+  seed7("onnx", "tensorflow", "enabled", "ONNX enables PyTorch \u2192 TensorFlow model conversion via ONNX as an intermediate format. Teams can train in PyTorch (research) and deploy in TensorFlow Serving (production) via ONNX.", 0.75),
+  // ── Inference & serving chain ─────────────────────────────────────────
+  seed7("pytorch", "vllm", "caused", "vLLM is built on PyTorch and CUDA. Its PagedAttention kernels are CUDA extensions, and the model loading uses PyTorch's weight format. No PyTorch \u2192 no vLLM.", 0.9),
+  seed7("llama_meta", "vllm", "accelerated", "LLaMA's open weights created the demand for efficient open-model inference. vLLM's PagedAttention was specifically developed to serve LLaMA-class models cost-effectively.", 0.82),
+  seed7("llama_meta", "ollama", "caused", "Ollama's library of models is primarily LLaMA variants (Llama 3, Code Llama, Mistral-based). LLaMA's open weights enabled the local inference ecosystem Ollama serves.", 0.88),
+  seed7("chatgpt", "ollama", "inspired", `Ollama's UX ("run a model with one command") mirrors the ChatGPT interface \u2014 except local, private, and free. ChatGPT set the interaction paradigm; Ollama made it self-hostable.`, 0.72),
+  seed7("transformer", "llama_meta", "caused", "LLaMA is a Transformer decoder LLM \u2014 same architecture as GPT. Meta's contribution was scaling the architecture efficiently and releasing the weights openly.", 0.95),
+  seed7("chatgpt", "llama_meta", "accelerated", "ChatGPT's success motivated Meta to release LLaMA \u2014 to ensure the open-source community had competitive weights rather than ceding AI to closed-source providers.", 0.78),
+  // ── AI developer tools ────────────────────────────────────────────────
+  seed7("vscode", "cursor_ide", "caused", "Cursor is a VS Code fork \u2014 it shares VS Code's extension ecosystem, settings, and keybindings. The fork was chosen to inherit VS Code's 70% market share and extension library.", 0.92),
+  seed7("github_copilot", "cursor_ide", "accelerated", `Copilot proved that AI completions in an IDE had real PMF. Cursor raised the ceiling: "what if the whole editor was designed for AI, not just completions?" Copilot's success validated the category.`, 0.82),
+  seed7("openai_api", "cursor_ide", "enabled", "Cursor uses GPT-4 and Claude models via API for multi-file editing and codebase chat. The OpenAI API (and Anthropic API) is what powers Cursor's intelligence.", 0.88),
+  seed7("cursor_ide", "mcp_protocol", "enabled", "Cursor adopted MCP as one of the first IDEs. Cursor's success with tool-augmented coding validated the MCP use case \u2014 agents need structured tool access, not just LLM intelligence.", 0.72),
+  seed7("transformer", "whisper", "caused", "Whisper is a Transformer encoder-decoder model \u2014 Transformer applied to audio spectrograms. The architecture is identical to the text Transformer; the input modality changed.", 0.92),
+  seed7("python", "ray", "caused", "Ray is a Python library. Distributed Python functions with `@ray.remote`. The entire Ray API is Python-first; other language bindings came later as thin wrappers.", 0.88),
+  seed7("kubernetes", "ray", "accelerated", "KubeRay operator made Ray a first-class Kubernetes workload. Production Ray deployments run on K8s; the operator handles scaling, fault recovery, and GPU resource management.", 0.75),
+  seed7("aws", "pytorch", "accelerated", "Amazon SageMaker (2017) adopted PyTorch as its primary framework and made managed GPU training available without cluster administration. AWS's cloud scale drove PyTorch adoption beyond research labs into production.", 0.7),
+  // ── Cross-vertical links ───────────────────────────────────────────────
+  seed7("pytorch", "transformer", "accelerated", "The Transformer architecture's research velocity was enabled by PyTorch's expressiveness for custom attention implementations. BERT, GPT-2, and every subsequent model was developed and iterated on in PyTorch.", 0.82),
+  seed7("huggingface_hub", "mcp_protocol", "enabled", "HuggingFace models are a primary MCP resource \u2014 agents can query model documentation, run inference via Inference API, and access model metadata. The Hub's API is MCP-composable.", 0.6),
+  seed7("rag_pattern", "mcp_protocol", "enabled", "MCP's Resource primitive is architecturally similar to RAG retrieval \u2014 fetch structured context before generation. MCP formalizes the retrieval-then-generate pattern into a protocol standard.", 0.72),
+  seed7("langchain", "mcp_protocol", "inspired", `LangChain's "Tool" abstraction (search tool, calculator tool, API tool) is the predecessor concept to MCP tools. MCP standardizes what LangChain demonstrated: agents need structured tool calls.`, 0.75)
+];
+
+// ../../packages/ckg/dist/seed/events-security.js
+var src6 = { type: "demo-seed", reliability: 0.9, citation: "Causari curated baseline \u2014 security" };
+var ev8 = (e) => ({ ...e, scope: "world", sources: [src6] });
+var securityEvents = [
+  ev8({
+    id: "pgp",
+    title: "PGP (Pretty Good Privacy)",
+    description: `Phil Zimmermann released PGP \u2014 public-key cryptography for email, made accessible. Asymmetric encryption, digital signatures, web of trust. First mass-market cryptography tool; sparked a US government legal battle that became the first "crypto wars." Established the principle that strong encryption belongs in everyone's hands.`,
+    yearNum: 1991,
+    yearLabel: "1991",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.68,
+    tags: ["pgp", "encryption", "public-key", "email", "privacy", "cryptography"],
+    wikidataId: "Q186675"
+  }),
+  ev8({
+    id: "ssl_tls",
+    title: "SSL/TLS Protocol",
+    description: "Netscape designed SSL (Secure Sockets Layer), later standardized as TLS \u2014 the encryption layer for web traffic. HTTPS = HTTP over TLS. Everything financial, medical, and private on the internet travels over TLS. Made e-commerce and online banking possible by solving authentication and confidentiality in one protocol.",
+    yearNum: 1994,
+    yearLabel: "1994",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.84,
+    tags: ["tls", "ssl", "https", "encryption", "protocol", "web-security"],
+    wikidataId: "Q214799"
+  }),
+  ev8({
+    id: "owasp",
+    title: "OWASP Top 10",
+    description: "The Open Web Application Security Project published the OWASP Top 10 \u2014 the standard awareness document for web application security. SQL injection, XSS, CSRF, broken auth. Became the universal security checklist: if your pentest doesn't cover OWASP Top 10, it's incomplete. Referenced in PCI-DSS and SOC2 audits.",
+    yearNum: 2003,
+    yearLabel: "2003",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.72,
+    tags: ["owasp", "security", "web-security", "vulnerability", "checklist", "appsec"],
+    wikidataId: "Q281285"
+  }),
+  ev8({
+    id: "cve_system",
+    title: "CVE System (Common Vulnerabilities)",
+    description: "MITRE launched the CVE (Common Vulnerabilities and Exposures) numbering system \u2014 a universal dictionary for publicly known security flaws. CVE-2021-44228 (Log4Shell) affected every Java app. Without CVE, coordinating patches across an ecosystem is impossible. The DNS of security vulnerabilities.",
+    yearNum: 1999,
+    yearLabel: "1999",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.7,
+    tags: ["cve", "vulnerability", "security", "mitre", "disclosure", "patching"],
+    wikidataId: "Q1043098"
+  }),
+  ev8({
+    id: "saml",
+    title: "SAML (Enterprise SSO)",
+    description: 'OASIS standardized SAML \u2014 Security Assertion Markup Language for enterprise single sign-on. XML-based identity federation between an Identity Provider (Okta, Azure AD) and Service Providers. Powers SSO at every large enterprise. "Sign in with your company account" is SAML.',
+    yearNum: 2002,
+    yearLabel: "2002",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.68,
+    tags: ["saml", "sso", "enterprise", "identity", "federation", "authentication"],
+    wikidataId: "Q294811"
+  }),
+  ev8({
+    id: "jwt",
+    title: "JWT (JSON Web Tokens)",
+    description: "IETF standardized JWT \u2014 self-contained, digitally signed tokens for authentication. Stateless auth: the token carries claims (user ID, roles, expiry); the server verifies the signature, no database lookup needed. Became the standard bearer format for OAuth 2.0 access tokens and API authentication.",
+    yearNum: 2010,
+    yearLabel: "2010",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.72,
+    tags: ["jwt", "authentication", "token", "stateless", "api-security", "oauth"],
+    wikidataId: "Q29294906"
+  }),
+  ev8({
+    id: "zero_trust",
+    title: "Zero Trust Security Model",
+    description: 'John Kindervag at Forrester coined "Zero Trust" \u2014 never trust, always verify. No implicit trust based on network location (VPN is not security). Google implemented it as BeyondCorp (2011): employees access apps via identity-aware proxy, not corporate network. Became mandatory framework for cloud-native security.',
+    yearNum: 2010,
+    yearLabel: "2010",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.76,
+    tags: ["zero-trust", "security", "beyondcorp", "identity", "network-security", "google"],
+    wikidataId: "Q97283052"
+  }),
+  ev8({
+    id: "oidc",
+    title: "OpenID Connect (OIDC)",
+    description: 'OpenID Foundation standardized OIDC \u2014 an identity layer on top of OAuth 2.0. If OAuth gives you authorization ("can this app read your files?"), OIDC gives you authentication ("who is this user?"). "Sign in with Google" is OIDC. Made federated identity the standard for consumer and enterprise apps alike.',
+    yearNum: 2014,
+    yearLabel: "2014",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.7,
+    tags: ["oidc", "openid-connect", "authentication", "oauth", "identity", "sso"],
+    wikidataId: "Q5003939"
+  }),
+  ev8({
+    id: "gdpr",
+    title: "GDPR (Data Privacy Regulation)",
+    description: `The EU's General Data Protection Regulation became enforceable \u2014 the strictest data privacy law in the world. Right to access, right to erasure, consent requirements, \u20AC20M fines. Forced every internet company to build privacy controls. Triggered cookie banners, data deletion workflows, and the "privacy by design" engineering discipline.`,
+    yearNum: 2018,
+    yearLabel: "2018",
+    precision: "year",
+    domains: ["technology", "systems", "economy"],
+    impactScore: 0.8,
+    tags: ["gdpr", "privacy", "regulation", "compliance", "data-protection", "europe"],
+    wikidataId: "Q104202095"
+  }),
+  ev8({
+    id: "soc2",
+    title: "SOC 2 Compliance",
+    description: `AICPA formalized SOC 2 (System and Organization Controls 2) \u2014 the security audit standard for cloud services. Five trust criteria: Security, Availability, Processing Integrity, Confidentiality, Privacy. "We're SOC 2 Type II compliant" became the minimum bar for selling B2B SaaS to enterprises. Shaped how cloud companies build.`,
+    yearNum: 2010,
+    yearLabel: "2010",
+    precision: "year",
+    domains: ["technology", "economy"],
+    impactScore: 0.68,
+    tags: ["soc2", "compliance", "audit", "b2b", "enterprise", "security"],
+    wikidataId: "Q17141313"
+  }),
+  ev8({
+    id: "dependabot",
+    title: "Dependabot (Dependency Security)",
+    description: "GitHub launched Dependabot \u2014 automated pull requests to update vulnerable dependencies. Scans package.json, Gemfile, requirements.txt; detects CVEs; opens PRs automatically. Made dependency security a default practice, not an afterthought. Free for public repos; integrated into every GitHub repository.",
+    yearNum: 2017,
+    yearLabel: "2017",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.66,
+    tags: ["dependabot", "security", "dependency", "cve", "automation", "github"],
+    wikidataId: "Q55638811"
+  }),
+  ev8({
+    id: "snyk",
+    title: "Snyk (Developer Security)",
+    description: 'Guy Podjarny built Snyk \u2014 security scanning built into developer workflows. `npm install --save` triggers a scan; PRs get security comments; CLI runs in CI. Pioneered "shift left security" \u2014 fix vulnerabilities in code review, not production. Reached $8.5B valuation.',
+    yearNum: 2015,
+    yearLabel: "2015",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.66,
+    tags: ["snyk", "security", "sast", "developer-tools", "vulnerability", "shift-left"],
+    wikidataId: "Q59236131"
+  }),
+  ev8({
+    id: "webauthn",
+    title: "WebAuthn / Passkeys",
+    description: 'W3C and FIDO Alliance standardized WebAuthn \u2014 browser API for passwordless authentication via biometrics, security keys, or device authenticators. Apple, Google, and Microsoft adopted the "Passkeys" brand in 2022. The first realistic path to eliminating passwords at internet scale.',
+    yearNum: 2019,
+    yearLabel: "2019",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.72,
+    tags: ["webauthn", "passkeys", "passwordless", "fido2", "biometrics", "authentication"],
+    wikidataId: "Q64099893"
+  }),
+  ev8({
+    id: "cors",
+    title: "CORS (Cross-Origin Resource Sharing)",
+    description: "W3C standardized CORS \u2014 the browser mechanism that controls which cross-origin HTTP requests are allowed. `Access-Control-Allow-Origin` is the most-Googled HTTP header in frontend development. CORS exists to enforce the Same-Origin Policy that protects users from malicious cross-site requests.",
+    yearNum: 2004,
+    yearLabel: "2004",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.62,
+    tags: ["cors", "browser", "security", "http", "same-origin", "api"],
+    wikidataId: "Q1073546"
+  }),
+  ev8({
+    id: "bug_bounty",
+    title: "Bug Bounty Programs",
+    description: 'Netscape paid the first "bug bounty" in 1995; HackerOne and Bugcrowd formalized the market in 2012. Crowdsourced security research: ethical hackers report vulnerabilities for rewards. Google, Microsoft, and every major tech company now runs bug bounty programs. Turned independent security research into a profession.',
+    yearNum: 2012,
+    yearLabel: "2012",
+    precision: "year",
+    domains: ["technology", "economy"],
+    impactScore: 0.62,
+    tags: ["bug-bounty", "hackerone", "security-research", "crowdsource", "responsible-disclosure"],
+    wikidataId: "Q4998734"
+  }),
+  ev8({
+    id: "supply_chain_security",
+    title: "Software Supply Chain Security",
+    description: 'The SolarWinds attack (2020) and Log4Shell (2021) made software supply chain security a board-level issue. SBOM (Software Bill of Materials), Sigstore, in-toto, SLSA framework \u2014 the industry built infrastructure to answer "what code is actually running in production?" A new discipline born from high-profile failures.',
+    yearNum: 2020,
+    yearLabel: "2020",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.74,
+    tags: ["supply-chain", "security", "sbom", "sigstore", "slsa", "solarwinds", "log4shell"],
+    wikidataId: "Q106891116"
+  }),
+  ev8({
+    id: "okta",
+    title: "Okta (Identity Platform)",
+    description: `Todd McKinnon built Okta \u2014 cloud identity and access management. Single sign-on, MFA, lifecycle management, API access management. Made enterprise-grade identity a SaaS product. "$8B identity tax" that every enterprise SaaS pays is Okta's market. Forced Azure AD into competing more aggressively.`,
+    yearNum: 2009,
+    yearLabel: "2009",
+    precision: "year",
+    domains: ["technology", "economy"],
+    impactScore: 0.7,
+    tags: ["okta", "identity", "sso", "mfa", "enterprise", "iam"],
+    wikidataId: "Q7079832"
+  }),
+  ev8({
+    id: "hashicorp_sentinel",
+    title: "Policy as Code (OPA / Sentinel)",
+    description: 'HashiCorp Sentinel (2017) and Open Policy Agent (2016) brought policy enforcement into code. "Is this Kubernetes deployment compliant?" \u2014 answer it with a policy file, not a spreadsheet. Shifted compliance from audit-after-deploy to enforce-at-deploy. Now standard in enterprise K8s, Terraform, and CI/CD pipelines.',
+    yearNum: 2017,
+    yearLabel: "2017",
+    precision: "year",
+    domains: ["technology", "systems"],
+    impactScore: 0.62,
+    tags: ["policy-as-code", "opa", "sentinel", "compliance", "kubernetes", "infrastructure"],
+    wikidataId: "Q60336079"
+  })
+];
+
+// ../../packages/ckg/dist/seed/links-security.js
+var seed8 = (f, t, rel, ev10, conf) => ({
+  id: `${f}--${rel}-->${t}`,
+  fromEvent: f,
+  toEvent: t,
+  relationship: rel,
+  confidence: conf ?? (rel === "caused" ? 0.9 : 0.8),
+  evidence: ev10,
+  sources: [{ type: "demo-seed", reliability: 0.9, citation: "Causari curated baseline \u2014 security" }],
+  contributedBy: "system",
+  validated: true,
+  scope: "world"
+});
+var securityLinks = [
+  // ── Cryptography foundation ────────────────────────────────────────────
+  seed8("pgp", "ssl_tls", "enabled", "PGP demonstrated that public-key cryptography was practically implementable at scale. Netscape designers of SSL built on the same public-key infrastructure concepts PGP popularized.", 0.65),
+  seed8("pgp", "vault", "inspired", "PGP's concept of key-based secrets management \u2014 asymmetric keys for identity, symmetric keys for data \u2014 informs how Vault stores and issues secrets via PKI.", 0.55),
+  seed8("ssl_tls", "web", "enabled", "HTTPS = HTTP over TLS. E-commerce, banking, and healthcare on the web require TLS. The web's commercial success was enabled by SSL/TLS making confidential transactions possible.", 0.9),
+  seed8("ssl_tls", "letsencrypt", "caused", "Let's Encrypt issues TLS certificates. The whole premise is providing SSL/TLS more easily. No TLS protocol \u2192 no Let's Encrypt.", 0.95),
+  seed8("ssl_tls", "oauth", "enabled", "OAuth requires HTTPS \u2014 access tokens transmitted over HTTP would be trivially intercepted. TLS is the security layer that makes OAuth's token-based delegation safe.", 0.88),
+  seed8("ssl_tls", "webauthn", "enabled", "WebAuthn requires HTTPS to function in browsers. The credential API is only available on secure origins. TLS is a prerequisite for the passwordless web.", 0.9),
+  // ── Auth standards chain ───────────────────────────────────────────────
+  seed8("saml", "oauth", "enabled", "SAML (2002) proved enterprise identity federation was possible and valuable. OAuth (2007) solved the same problem for web APIs \u2014 lighter weight, JSON-native, browser-friendly.", 0.72),
+  seed8("saml", "oidc", "inspired", "OIDC was designed to replace SAML for consumer applications \u2014 same SSO capability, but REST/JSON instead of XML/SOAP. Every OIDC concept (IdP, SP/RP, claims) has a SAML predecessor.", 0.82),
+  seed8("oauth", "oidc", "caused", 'OIDC is an identity layer built on top of OAuth 2.0. OAuth handles authorization; OIDC adds the "who is this user?" layer. No OAuth 2.0 \u2192 no OIDC.', 0.95),
+  seed8("oauth", "jwt", "enabled", "JWT became the standard format for OAuth 2.0 access tokens and OIDC ID tokens. OAuth needed a compact, verifiable token format; JWT provided it.", 0.88),
+  seed8("jwt", "oidc", "enabled", "OIDC's ID Token is a JWT. The claims about the authenticated user (sub, email, name) travel in a JWT that the client can verify without a server round-trip.", 0.9),
+  seed8("jwt", "oauth", "accelerated", "JWT made OAuth tokens self-validating \u2014 resource servers verify the signature without calling the authorization server. This enabled stateless microservice authentication at scale.", 0.82),
+  seed8("saml", "okta", "caused", "Okta was built to make SAML SSO manageable. Enterprise apps all required SAML integration; Okta became the hub that handled SAML for every SaaS vendor without individual IT configuration.", 0.85),
+  seed8("oidc", "okta", "caused", "Okta implemented OIDC alongside SAML to serve consumer and modern enterprise apps. OIDC made Okta relevant beyond legacy enterprise into developer-first and SaaS applications.", 0.82),
+  seed8("webauthn", "okta", "accelerated", "Okta added WebAuthn/passkey support to its platform \u2014 hardware security keys and biometrics as MFA factors. WebAuthn made phishing-resistant MFA a first-class Okta feature.", 0.72),
+  // ── Compliance & regulation ────────────────────────────────────────────
+  seed8("internet", "gdpr", "caused", 'GDPR was created because the internet enabled unprecedented collection and processing of personal data at scale. The regulation exists because internet services defaulted to "collect everything."', 0.85),
+  seed8("aws", "soc2", "accelerated", 'AWS becoming the enterprise default for infrastructure raised SOC 2 compliance from a nice-to-have to a requirement. Enterprises asking "is your cloud vendor SOC 2 compliant?" pushed every SaaS to certify.', 0.72),
+  seed8("gdpr", "soc2", "accelerated", "GDPR created organizational awareness of data governance. SOC 2 (US) and GDPR (EU) together became the dual compliance minimum that any SaaS selling to enterprises needed.", 0.68),
+  seed8("soc2", "vault", "enabled", "SOC 2 controls require auditable secrets management (CC6.1-CC6.7 logical access). Vault's dynamic credentials, audit log, and access policies map directly to SOC 2 control requirements.", 0.75),
+  seed8("gdpr", "okta", "accelerated", `GDPR's "right to erasure" and "consent management" requirements made user identity management a compliance challenge. Okta's lifecycle management and audit logging helped enterprises demonstrate GDPR compliance.`, 0.65),
+  seed8("owasp", "snyk", "enabled", "Snyk's vulnerability categories and remediation guidance are organized around OWASP risks. OWASP Top 10 is the standard Snyk references when explaining why a dependency is dangerous.", 0.75),
+  seed8("cve_system", "snyk", "caused", "Snyk's security database is built on CVE data. Snyk scans for CVE-listed vulnerabilities in dependencies. Without the CVE numbering system, Snyk's vulnerability tracking lacks a common identifier.", 0.88),
+  seed8("cve_system", "dependabot", "caused", "Dependabot opens PRs when dependencies have known CVE vulnerabilities. The CVE database is Dependabot's primary signal for what is dangerous. No CVE \u2192 no meaningful Dependabot alerts.", 0.9),
+  seed8("owasp", "cors", "enabled", "CORS was designed to enforce the Same-Origin Policy, which prevents the CSRF and data exfiltration attacks that appear in OWASP Top 10. OWASP's articulation of XSS and CSRF drove CORS specification.", 0.72),
+  // ── Developer security tooling ─────────────────────────────────────────
+  seed8("github", "dependabot", "caused", "Dependabot was a startup (Dependabot.io) acquired by GitHub in 2019. GitHub built it into every repository for free. GitHub's distribution made Dependabot the default dependency scanner.", 0.92),
+  seed8("github", "supply_chain_security", "enabled", "GitHub is where most open-source supply chain attacks surface \u2014 malicious npm packages, typosquatting, compromised maintainer accounts. GitHub Actions workflows can introduce supply chain risks via third-party actions.", 0.82),
+  seed8("cve_system", "supply_chain_security", "enabled", "Supply chain security starts with CVE detection. Log4Shell (CVE-2021-44228) was the event that made boards care about software supply chain. The CVE system is the vocabulary for the entire discipline.", 0.88),
+  seed8("dependabot", "supply_chain_security", "accelerated", "Dependabot automated the first line of supply chain defense \u2014 keeping dependencies up to date. But SolarWinds proved that updates themselves can be compromised, expanding supply chain security beyond just version pinning.", 0.72),
+  seed8("snyk", "supply_chain_security", "accelerated", "Snyk's container scanning and license compliance checks address supply chain integrity beyond CVEs. Snyk positioned itself as the developer-security platform for the supply chain era.", 0.72),
+  seed8("kubernetes", "hashicorp_sentinel", "enabled", "OPA Gatekeeper runs as a Kubernetes admission controller \u2014 it enforces policies on every resource creation request. Kubernetes's admission webhook API is what makes policy-as-code enforceable at the cluster level.", 0.85),
+  seed8("terraform", "hashicorp_sentinel", "caused", "HashiCorp Sentinel is the policy engine for Terraform Enterprise/Cloud. Sentinel policies enforce compliance on Terraform plans before `apply`. HashiCorp built Sentinel specifically for Terraform governance.", 0.9),
+  seed8("vault", "kubernetes", "accelerated", "Vault's Kubernetes auth method made secrets injection into pods the standard pattern. The Vault Agent Injector (sidecar) and Secrets Store CSI driver made Vault-managed secrets native to K8s workloads.", 0.75),
+  // ── Zero trust chain ───────────────────────────────────────────────────
+  seed8("zero_trust", "okta", "accelerated", "Zero Trust requires identity as the control plane \u2014 every access request verified regardless of network. Okta is the identity layer zero trust architectures are built on: no network perimeter, only verified identity.", 0.82),
+  seed8("zero_trust", "vault", "accelerated", "Zero Trust extends to infrastructure secrets \u2014 no implicit trust for service-to-service calls. Vault's dynamic credentials and PKI are the secrets management layer in a zero-trust architecture.", 0.78),
+  seed8("zero_trust", "cloudflare", "accelerated", "Cloudflare Zero Trust (ZTNA) is a commercial zero-trust product. Cloudflare's global network became the access proxy that enforces identity-aware access without a VPN.", 0.78),
+  seed8("aws", "zero_trust", "accelerated", "AWS's IAM model \u2014 fine-grained, role-based access with no implicit trust \u2014 embodies zero trust at the cloud layer. AWS's scale normalized the zero-trust thinking for infrastructure access.", 0.68),
+  // ── Web security chain ────────────────────────────────────────────────
+  seed8("web", "owasp", "caused", "OWASP was created to address web application security. The web's openness (anyone can submit data, anyone can access endpoints) created the attack surface OWASP documents.", 0.9),
+  seed8("web", "cors", "caused", "CORS is a browser mechanism for web cross-origin requests. It exists because the web's same-origin policy needed a controlled relaxation mechanism for legitimate cross-origin APIs.", 0.92),
+  seed8("owasp", "supply_chain_security", "enabled", 'OWASP expanded its scope to include "A06:2021 Vulnerable and Outdated Components" \u2014 the supply chain attack surface. OWASP top 10 entry legitimized supply chain as a web security concern.', 0.72),
+  seed8("bug_bounty", "supply_chain_security", "enabled", "Bug bounty programs created a community of security researchers who now focus on supply chain vulnerabilities. The same researchers who found XSS bugs discovered typosquatting and dependency hijacking.", 0.6),
+  seed8("letsencrypt", "webauthn", "enabled", "WebAuthn requires HTTPS. Let's Encrypt made HTTPS free and ubiquitous, removing the last barrier to deploying WebAuthn on any website. No free TLS \u2192 WebAuthn adoption would lag.", 0.78),
+  seed8("jwt", "mcp_protocol", "enabled", "MCP authentication (OAuth 2.1 for remote servers) uses JWT access tokens. JWT's self-validating stateless nature fits MCP's distributed tool-call model where servers verify tokens without a central auth server call.", 0.72),
+  seed8("oauth", "mcp_protocol", "enabled", "MCP's authorization spec is built on OAuth 2.1. Remote MCP servers that handle sensitive data use OAuth for client authorization. The web's authorization standard became the agent protocol's authorization standard.", 0.82)
+];
+
+// ../../packages/ckg/dist/seed/events-mobile.js
+var src7 = { type: "demo-seed", reliability: 0.9, citation: "Causari curated baseline \u2014 mobile" };
+var ev9 = (e) => ({ ...e, scope: "world", sources: [src7] });
+var mobileEvents = [
+  ev9({
+    id: "android",
+    title: "Android",
+    description: "Google released Android \u2014 an open-source mobile operating system based on Linux. Free for OEMs, built on Java/Kotlin, Google Play for distribution. Runs on 73% of smartphones globally. Created a hardware ecosystem where Apple's iOS couldn't: hundreds of manufacturers, every price point, every market.",
+    yearNum: 2008,
+    yearLabel: "2008",
+    precision: "year",
+    domains: ["technology", "economy"],
+    impactScore: 0.86,
+    tags: ["android", "mobile", "google", "open-source", "smartphone", "linux"],
+    wikidataId: "Q94"
+  }),
+  ev9({
+    id: "app_store",
+    title: "App Store (Apple)",
+    description: 'Apple launched the App Store \u2014 the first large-scale curated mobile app marketplace. Third-party apps on iPhone; 30% commission; review process. Created the "app economy": $1T+ cumulative developer earnings. Established the platform-as-distribution model and sparked the debate over whether 30% is monopolistic.',
+    yearNum: 2008,
+    yearLabel: "2008",
+    precision: "year",
+    domains: ["technology", "economy"],
+    impactScore: 0.82,
+    tags: ["app-store", "apple", "ios", "distribution", "marketplace", "mobile"],
+    wikidataId: "Q368744"
+  }),
+  ev9({
+    id: "swift",
+    title: "Swift (Apple Programming Language)",
+    description: "Chris Lattner at Apple released Swift \u2014 a modern, type-safe replacement for Objective-C. Fast, readable, open-sourced in 2015. Lowered the barrier to iOS development significantly. Swift Playgrounds made it the first language many learned on an iPad. Now extends to server-side (Vapor) and ML (Swift for TensorFlow).",
+    yearNum: 2014,
+    yearLabel: "2014",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.72,
+    tags: ["swift", "ios", "apple", "programming", "language", "type-safe"],
+    wikidataId: "Q17118040"
+  }),
+  ev9({
+    id: "kotlin",
+    title: "Kotlin",
+    description: "JetBrains released Kotlin \u2014 a modern, concise, null-safe JVM language. Google announced Kotlin as the preferred language for Android development in 2017. Interoperable with Java: teams could migrate incrementally. Coroutines for async, data classes for models, extension functions for clean APIs. The language Java should have been.",
+    yearNum: 2016,
+    yearLabel: "2016",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.7,
+    tags: ["kotlin", "android", "jvm", "programming", "coroutines", "google"],
+    wikidataId: "Q3816639"
+  }),
+  ev9({
+    id: "flutter",
+    title: "Flutter",
+    description: "Google released Flutter \u2014 a UI toolkit that compiles Dart to native iOS, Android, web, desktop, and embedded targets from one codebase. No JavaScript bridge: renders its own pixels via Skia/Impeller. Proved that compile-to-native cross-platform was viable and challenged React Native's JS bridge model.",
+    yearNum: 2018,
+    yearLabel: "2018",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.74,
+    tags: ["flutter", "dart", "cross-platform", "mobile", "google", "native-rendering"],
+    wikidataId: "Q56513020"
+  }),
+  ev9({
+    id: "expo",
+    title: "Expo (React Native Platform)",
+    description: "Charlie Cheever built Expo \u2014 the managed React Native platform. `npx create-expo-app` \u2192 build for iOS and Android without Xcode or Android Studio. Over-the-air updates, build service, device testing app. Reduced React Native's setup from days to minutes and became the entry point for most new React Native projects.",
+    yearNum: 2015,
+    yearLabel: "2015",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.66,
+    tags: ["expo", "react-native", "mobile", "cross-platform", "ota-updates"],
+    wikidataId: "Q97520490"
+  }),
+  ev9({
+    id: "firebase",
+    title: "Firebase (Google App Platform)",
+    description: `Google acquired and expanded Firebase into a full app development platform: real-time database, Firestore, authentication, cloud functions, hosting, and analytics. "Your app's backend without a backend." The fastest way to ship a mobile or web app with user auth, data storage, and hosting included.`,
+    yearNum: 2014,
+    yearLabel: "2014",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.74,
+    tags: ["firebase", "google", "baas", "mobile", "realtime", "serverless"],
+    wikidataId: "Q17099233"
+  }),
+  ev9({
+    id: "xcode",
+    title: "Xcode (Apple IDE)",
+    description: "Apple's integrated development environment for macOS, iOS, watchOS, and tvOS development. The only way to compile and submit apps to the App Store. Interface Builder, Instruments profiler, Simulator, and SwiftUI previews. Love-hate relationship: essential monopoly with notoriously slow build times.",
+    yearNum: 2003,
+    yearLabel: "2003",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.62,
+    tags: ["xcode", "apple", "ide", "ios", "macos", "swift"],
+    wikidataId: "Q306518"
+  }),
+  ev9({
+    id: "android_studio",
+    title: "Android Studio",
+    description: "Google launched Android Studio (replacing Eclipse ADT) \u2014 the official Android IDE based on IntelliJ IDEA. Layout Editor, Emulator, ADB, Logcat, Profiler in one. Made Android development significantly more ergonomic. Kotlin-first since 2017, now with Compose previews and Gemini integration.",
+    yearNum: 2013,
+    yearLabel: "2013",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.62,
+    tags: ["android-studio", "android", "ide", "google", "kotlin", "jetbrains"],
+    wikidataId: "Q13218560"
+  }),
+  ev9({
+    id: "fastlane",
+    title: "Fastlane (Mobile CI/CD)",
+    description: 'Felix Krause built Fastlane \u2014 automation tooling for iOS and Android build, test, and release pipelines. Code signing, beta distribution (TestFlight, Google Play), screenshot generation, App Store submission \u2014 all scriptable. The "GitHub Actions for mobile" before mobile CI was a solved problem.',
+    yearNum: 2015,
+    yearLabel: "2015",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.64,
+    tags: ["fastlane", "mobile", "ci-cd", "ios", "android", "automation"],
+    wikidataId: "Q21097087"
+  }),
+  ev9({
+    id: "jetpack_compose",
+    title: "Jetpack Compose",
+    description: "Google released Jetpack Compose \u2014 a declarative UI toolkit for Android in Kotlin. Same component model as React/SwiftUI: composable functions, unidirectional data flow, reactive state. Replaced XML layouts. Made Android UI development feel modern for the first time and triggered complete ecosystem migration.",
+    yearNum: 2021,
+    yearLabel: "2021",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.68,
+    tags: ["jetpack-compose", "android", "kotlin", "declarative-ui", "google", "reactive"],
+    wikidataId: "Q108508867"
+  }),
+  ev9({
+    id: "swiftui",
+    title: "SwiftUI",
+    description: "Apple released SwiftUI \u2014 a declarative UI framework for all Apple platforms. Write UI in Swift code with live previews in Xcode. Replaced UIKit's imperative, delegate-heavy pattern with composable views and state bindings. The Apple ecosystem's answer to React's component model.",
+    yearNum: 2019,
+    yearLabel: "2019",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.68,
+    tags: ["swiftui", "swift", "apple", "declarative-ui", "ios", "macos"],
+    wikidataId: "Q65073619"
+  }),
+  ev9({
+    id: "capacitor",
+    title: "Capacitor (Ionic)",
+    description: "Ionic released Capacitor \u2014 a native bridge for web apps on iOS, Android, and desktop. Modern replacement for Cordova: ES modules, TypeScript first, access native APIs from web code. Enabled teams to ship mobile apps using their existing web tech stack with native plugin access.",
+    yearNum: 2019,
+    yearLabel: "2019",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.6,
+    tags: ["capacitor", "ionic", "hybrid", "mobile", "webview", "cross-platform"],
+    wikidataId: "Q87133781"
+  }),
+  ev9({
+    id: "google_play",
+    title: "Google Play Store",
+    description: "Google launched Android Market (later Play Store) \u2014 the primary distribution channel for Android apps. Lower barrier than App Store (sideloading allowed, faster review). 3.5M+ apps, 2.5B+ active users. Creates the duopoly with Apple App Store that defines mobile software distribution economics.",
+    yearNum: 2008,
+    yearLabel: "2008",
+    precision: "year",
+    domains: ["technology", "economy"],
+    impactScore: 0.78,
+    tags: ["google-play", "android", "distribution", "marketplace", "google", "mobile"],
+    wikidataId: "Q79576"
+  }),
+  ev9({
+    id: "tauri",
+    title: "Tauri (Rust Desktop Apps)",
+    description: `Tauri brought Rust as the backend for cross-platform desktop apps, using the system webview instead of bundling Chromium. 10x smaller bundle sizes than Electron, no Node.js runtime. Showed that web-based desktop apps didn't need to ship a full browser, sparking the "Rust for tooling" trend.`,
+    yearNum: 2020,
+    yearLabel: "2020",
+    precision: "year",
+    domains: ["technology"],
+    impactScore: 0.62,
+    tags: ["tauri", "rust", "desktop", "cross-platform", "electron-alternative", "webview"],
+    wikidataId: "Q108508879"
+  })
+];
+
+// ../../packages/ckg/dist/seed/links-mobile.js
+var seed9 = (f, t, rel, ev10, conf) => ({
+  id: `${f}--${rel}-->${t}`,
+  fromEvent: f,
+  toEvent: t,
+  relationship: rel,
+  confidence: conf ?? (rel === "caused" ? 0.9 : 0.8),
+  evidence: ev10,
+  sources: [{ type: "demo-seed", reliability: 0.9, citation: "Causari curated baseline \u2014 mobile" }],
+  contributedBy: "system",
+  validated: true,
+  scope: "world"
+});
+var mobileLinks = [
+  // ── Platform foundation ────────────────────────────────────────────────
+  seed9("iphone", "app_store", "caused", "The App Store was created alongside iPhone OS 2.0. The App Store is the distribution mechanism for iPhone apps \u2014 inseparable from the product.", 0.95),
+  seed9("iphone", "android", "accelerated", "Android existed before iPhone launch but was originally BlackBerry-like. iPhone's touchscreen paradigm forced Android's complete UI redesign. iPhone acceleration of Android's consumer-friendliness is documented by former Google engineers.", 0.82),
+  seed9("iphone", "swift", "enabled", "Swift replaced Objective-C for iOS development. No iPhone/iOS ecosystem \u2192 no need for a modern Apple programming language.", 0.88),
+  seed9("linux", "android", "caused", "Android is built on a modified Linux kernel. Linux provides the hardware abstraction layer, process management, and driver model that Android runs on. No Linux \u2192 no Android.", 0.95),
+  seed9("android", "google_play", "caused", "Google Play is Android's app distribution platform. The Play Store was launched the same day as the first Android device (T-Mobile G1). No Android \u2192 no Google Play.", 0.95),
+  seed9("app_store", "google_play", "accelerated", "Google Play was launched to match Apple's App Store model. The commercial success of the App Store (10M downloads in first weekend) made Google accelerate Android Market's launch.", 0.82),
+  // ── Language & tooling chain ───────────────────────────────────────────
+  seed9("java", "android", "caused", "Android's original development language was Java \u2014 Android apps ran on the Dalvik JVM (later ART). Google chose Java to leverage the massive Java developer community. No Java \u2192 Android would have needed a different language.", 0.88),
+  seed9("java", "kotlin", "caused", "Kotlin is a JVM language \u2014 it compiles to the same bytecode as Java and interoperates with Java libraries. No Java/JVM \u2192 no Kotlin. Kotlin exists to improve Java, not replace the JVM.", 0.88),
+  seed9("kotlin", "android", "accelerated", "Google announced Kotlin as the preferred Android language in 2017. Kotlin's adoption as the official language accelerated Android development quality and reduced boilerplate dramatically.", 0.82),
+  seed9("kotlin", "jetpack_compose", "caused", "Jetpack Compose is written in Kotlin and requires Kotlin \u2014 composable functions use Kotlin's language features (coroutines, DSL builders, extension functions). No Kotlin \u2192 no Compose.", 0.95),
+  seed9("reactjs", "swiftui", "inspired", `SwiftUI's declarative, component-based model directly mirrors React's. Apple studied React's success and built SwiftUI with the same "UI as a function of state" philosophy.`, 0.82),
+  seed9("reactjs", "jetpack_compose", "inspired", "Jetpack Compose follows the same declarative UI paradigm as React \u2014 `@Composable` functions mirror React components, state hoisting mirrors React's lifting state up, and unidirectional data flow is the same pattern.", 0.82),
+  // ── Cross-platform frameworks ──────────────────────────────────────────
+  seed9("reactjs", "react_native", "caused", "React Native is React for native mobile. No React \u2192 no React Native; the component model, JSX, and hooks are shared.", 0.95),
+  seed9("react_native", "expo", "caused", "Expo is a platform built on React Native. No React Native \u2192 no Expo. Expo's entire purpose is to make React Native easier.", 0.95),
+  seed9("react_native", "capacitor", "inspired", `Capacitor provides the same "write once, deploy mobile" promise as React Native but for web tech teams that don't want to learn React Native's native module system. Web + native bridge is the shared concept.`, 0.65),
+  seed9("flutter", "react_native", "inspired", `Flutter was built partly as a reaction to React Native's JavaScript bridge performance bottleneck. Flutter's "compile to native, no bridge" architecture is designed to solve React Native's performance concerns.`, 0.75),
+  seed9("golang", "flutter", "inspired", "Google created both Go and Dart (Flutter's language) as alternatives to incumbent languages for different domains. Go for server infrastructure; Dart for client UI. Both reflect Google's philosophy of purpose-built languages over incumbent compromise.", 0.45),
+  seed9("electron", "tauri", "inspired", "Tauri was built as a reaction to Electron's main criticism: bundled Chromium makes apps 150MB+. Tauri uses the system webview, keeping apps under 15MB. Every Tauri design decision is an Electron anti-decision.", 0.88),
+  seed9("rust_1_0", "tauri", "caused", "Tauri uses Rust for its native backend layer. Rust's memory safety and performance characteristics made it ideal for a secure, lightweight desktop app runtime without the overhead of Node.js.", 0.88),
+  seed9("webassembly", "tauri", "enabled", "Tauri's next-gen architecture (Tauri v2) integrates WASM for cross-platform plugins. WASM enables Tauri plugins to run safely in a sandboxed environment across Windows, macOS, and Linux.", 0.65),
+  // ── Backend for mobile ─────────────────────────────────────────────────
+  seed9("firebase_rtdb", "firebase", "caused", "Firebase Realtime Database was Firebase's original product. Google acquired Firebase (2014) and expanded it, but the RTDB is the founding product.", 0.92),
+  seed9("firebase", "react_native", "accelerated", 'Firebase + React Native became the default "build an MVP mobile app" stack. Firebase handles auth, data, and push notifications without a custom backend; React Native handles the UI.', 0.78),
+  seed9("firebase", "expo", "accelerated", "Expo + Firebase is a common combination \u2014 Expo for the cross-platform build/distribution, Firebase for the backend. Both reduce mobile app development to primarily frontend work.", 0.72),
+  seed9("aws", "firebase", "accelerated", "AWS Amplify (2017) was Amazon's direct response to Firebase \u2014 same BaaS concept for mobile, but on AWS infrastructure. Firebase's success with mobile developers prompted AWS to enter the BaaS market.", 0.68),
+  // ── Dev tooling chain ──────────────────────────────────────────────────
+  seed9("xcode", "swift", "accelerated", "Xcode gained Swift support on day one (2014 WWDC). Xcode's Playgrounds feature made Swift's interactive REPL a learning tool. Xcode's tight integration with Swift drove adoption.", 0.82),
+  seed9("xcode", "swiftui", "accelerated", "Xcode's SwiftUI canvas (live preview of UI components as you type) was a key selling feature of SwiftUI. Without Xcode's preview infrastructure, SwiftUI's DX advantage disappears.", 0.85),
+  seed9("android_studio", "kotlin", "accelerated", "Android Studio added first-class Kotlin support (autocomplete, refactoring, inspection) in 2017, the same year Google announced Kotlin as preferred. IDE support was crucial to adoption.", 0.82),
+  seed9("android_studio", "jetpack_compose", "accelerated", "Compose previews in Android Studio (live rendering of @Composable functions) are the key DX feature of Compose. Without Android Studio's preview, Compose adoption would be slower.", 0.82),
+  seed9("github_actions", "fastlane", "accelerated", "GitHub Actions + Fastlane is the standard mobile CI/CD pipeline. Actions triggers builds; Fastlane handles code signing, building, and distributing to TestFlight/Play Store.", 0.78),
+  seed9("git", "fastlane", "enabled", "Fastlane integrates with Git \u2014 Fastlane lanes are triggered by git events, version tags, and branch strategies. Version management (`increment_build_number`) ties to git history.", 0.72),
+  // ── Mobile → web platform convergence ─────────────────────────────────
+  seed9("pwa", "expo", "enabled", "Expo supports PWA output \u2014 the same Expo project can compile to iOS, Android, and a PWA. PWA's service worker support on mobile browsers reduces the gap between Expo web and native.", 0.65),
+  seed9("react_native", "pwa", "enabled", 'React Native Web (same component code targeting DOM) and PWA together enable "universal apps" \u2014 one React codebase targeting iOS, Android, and progressive web simultaneously.', 0.65),
+  seed9("iphone", "pwa", "accelerated", "Apple's reluctance to support PWA features (push notifications, home screen install) \u2014 and eventual capitulation (iOS 16.4+) \u2014 was driven by iPhone's dominant market position creating PWA adoption pressure.", 0.6)
+];
+
+// ../../packages/ckg/dist/seed/index.js
+function loadSeed() {
+  return {
+    events: [
+      ...seedEvents,
+      ...aiHistoryEvents,
+      ...computingEvents,
+      ...webEcosystemEvents,
+      ...cloudDevopsEvents,
+      ...databaseEvents,
+      ...aiToolingEvents,
+      ...securityEvents,
+      ...mobileEvents
+    ],
+    causalLinks: [
+      ...seedLinks,
+      ...aiHistoryLinks,
+      ...computingLinks,
+      ...webEcosystemLinks,
+      ...cloudDevopsLinks,
+      ...databaseLinks,
+      ...aiToolingLinks,
+      ...securityLinks,
+      ...mobileLinks
+    ],
+    insights: seedInsights
+  };
+}
+
+// ../../packages/ckg/dist/query.js
+function queryEvents(store, params) {
+  const limit = params.limit ?? 20;
+  const scope = params.scope ?? "world";
+  const q = params.query?.toLowerCase().trim();
+  const scored = [];
+  for (const e of store.allEvents()) {
+    if (e.scope !== scope)
+      continue;
+    if (params.yearFrom !== void 0 && e.yearNum < params.yearFrom)
+      continue;
+    if (params.yearTo !== void 0 && e.yearNum > params.yearTo)
+      continue;
+    if (params.minImpact !== void 0 && e.impactScore < params.minImpact)
+      continue;
+    if (params.domains && params.domains.length > 0) {
+      if (!e.domains.some((d) => params.domains.includes(d)))
+        continue;
+    }
+    let relevance = 0;
+    if (q) {
+      const titleLc = e.title.toLowerCase();
+      const tagMatch = e.tags.some((t) => t.toLowerCase().includes(q));
+      const descMatch = e.description.toLowerCase().includes(q);
+      const idMatch = e.id.toLowerCase() === q;
+      const titleStarts = titleLc.startsWith(q);
+      const titleHas = titleLc.includes(q);
+      if (idMatch)
+        relevance = 1;
+      else if (titleStarts)
+        relevance = 0.9;
+      else if (titleHas)
+        relevance = 0.75;
+      else if (tagMatch)
+        relevance = 0.6;
+      else if (descMatch)
+        relevance = 0.4;
+      else
+        continue;
+    } else {
+      relevance = 0;
+    }
+    scored.push({ event: e, relevance });
+  }
+  scored.sort((a, b) => {
+    if (q && a.relevance !== b.relevance)
+      return b.relevance - a.relevance;
+    if (b.event.impactScore !== a.event.impactScore)
+      return b.event.impactScore - a.event.impactScore;
+    return a.event.yearNum - b.event.yearNum;
+  });
+  const matched = scored.map((s) => s.event);
+  return {
+    events: matched.slice(0, limit),
+    totalMatched: matched.length,
+    truncated: matched.length > limit
+  };
+}
+function causalChain(store, params) {
+  const direction = params.direction ?? "both";
+  const depth = Math.min(Math.max(params.depth ?? 2, 1), 5);
+  const minConf = params.minConfidence ?? 0;
+  let root = store.getEvent(params.event);
+  if (!root) {
+    const needle = params.event.toLowerCase();
+    root = store.allEvents().find((e) => e.title.toLowerCase().includes(needle));
+  }
+  if (!root)
+    return { notFound: params.event };
+  const visited = /* @__PURE__ */ new Set([root.id]);
+  const nodes = [{ event: root, hop: 0, direction: "root" }];
+  const links = [];
+  if (direction === "causes" || direction === "both") {
+    let frontier = [root.id];
+    for (let hop = 1; hop <= depth; hop++) {
+      const next = [];
+      for (const id of frontier) {
+        for (const link of store.incomingTo(id, minConf)) {
+          if (!visited.has(link.fromEvent)) {
+            visited.add(link.fromEvent);
+            const ev10 = store.getEvent(link.fromEvent);
+            if (ev10) {
+              nodes.push({ event: ev10, hop, direction: "cause", via: link });
+              links.push(link);
+              next.push(ev10.id);
+            }
+          } else if (!links.find((l) => l.id === link.id)) {
+            links.push(link);
+          }
+        }
+      }
+      frontier = next;
+      if (frontier.length === 0)
+        break;
+    }
+  }
+  if (direction === "effects" || direction === "both") {
+    let frontier = [root.id];
+    const downVisited = /* @__PURE__ */ new Set([root.id]);
+    for (let hop = 1; hop <= depth; hop++) {
+      const next = [];
+      for (const id of frontier) {
+        for (const link of store.outgoingFrom(id, minConf)) {
+          if (!downVisited.has(link.toEvent)) {
+            downVisited.add(link.toEvent);
+            const ev10 = store.getEvent(link.toEvent);
+            if (ev10) {
+              if (!nodes.find((n) => n.event.id === ev10.id)) {
+                nodes.push({ event: ev10, hop, direction: "effect", via: link });
+              }
+              if (!links.find((l) => l.id === link.id))
+                links.push(link);
+              next.push(ev10.id);
+            }
+          } else if (!links.find((l) => l.id === link.id)) {
+            links.push(link);
+          }
+        }
+      }
+      frontier = next;
+      if (frontier.length === 0)
+        break;
+    }
+  }
+  const linkIds = new Set(links.map((l) => l.id));
+  const relatedInsights = store.allInsights().filter((i) => i.instances.some((linkId) => linkIds.has(linkId)));
+  return { root, nodes, links, relatedInsights };
+}
+function historicalResonance(store, params) {
+  const max = params.maxResults ?? 3;
+  const tokens = tokenize(params.situation);
+  const candidates = store.allInsights().map((insight) => {
+    const haystack = tokenize(`${insight.pattern} ${insight.description}`);
+    const overlap = countOverlap(tokens, haystack);
+    let score = overlap / Math.max(tokens.length, 1);
+    if (params.domains && params.domains.length > 0) {
+      const domainOverlap = insight.domains.filter((d) => params.domains.includes(d)).length;
+      score += domainOverlap * 0.15;
+    }
+    score += insight.predictiveValue * 0.2;
+    const exemplarEventIds = /* @__PURE__ */ new Set();
+    for (const linkId of insight.instances) {
+      const link = store.getLink(linkId);
+      if (link) {
+        exemplarEventIds.add(link.fromEvent);
+        exemplarEventIds.add(link.toEvent);
+      }
+    }
+    const exemplarEvents = Array.from(exemplarEventIds).map((id) => store.getEvent(id)).filter((e) => e !== void 0).sort((a, b) => a.yearNum - b.yearNum).slice(0, 4);
+    const reasoning = buildResonanceReasoning(insight, overlap, tokens.length, params.situation);
+    return { insight, matchScore: Math.min(score, 1), exemplarEvents, reasoning };
+  });
+  candidates.sort((a, b) => b.matchScore - a.matchScore);
+  return { matches: candidates.filter((c) => c.matchScore > 0.05).slice(0, max) };
+}
+function tokenize(s) {
+  return s.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((t) => t.length >= 3 && !STOP_WORDS.has(t));
+}
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "for",
+  "are",
+  "was",
+  "were",
+  "has",
+  "had",
+  "have",
+  "this",
+  "that",
+  "with",
+  "from",
+  "they",
+  "their",
+  "will",
+  "would",
+  "should",
+  "could",
+  "about",
+  "into",
+  "than",
+  "them",
+  "these",
+  "those",
+  "when",
+  "where",
+  "while",
+  "because",
+  "after",
+  "before"
+]);
+function countOverlap(a, b) {
+  const setB = new Set(b);
+  let count = 0;
+  const seen = /* @__PURE__ */ new Set();
+  for (const tok of a) {
+    if (setB.has(tok) && !seen.has(tok)) {
+      count++;
+      seen.add(tok);
+    }
+  }
+  return count;
+}
+function buildResonanceReasoning(insight, overlap, total, situation) {
+  const overlapPct = Math.round(overlap / Math.max(total, 1) * 100);
+  return `Pattern "${insight.pattern}" matches your situation on ${overlap}/${total} keywords (${overlapPct}%). The insight's predictive value is ${Math.round(insight.predictiveValue * 100)}%. Apply with caution \u2014 historical patterns inform but do not determine outcomes.`;
+}
+function orgKnowledge(store, params) {
+  const events = store.allEvents().filter((e) => e.scope === "org" && e.orgId === params.orgId);
+  if (events.length === 0) {
+    return {
+      events: [],
+      causalContext: [],
+      available: false,
+      message: "No org-scoped knowledge graph configured for this org. Private org knowledge is a Causari Enterprise feature."
+    };
+  }
+  const result = queryEvents(store, {
+    query: params.query,
+    yearFrom: params.yearFrom,
+    yearTo: params.yearTo,
+    scope: "org"
+  });
+  const matchedIds = new Set(result.events.map((e) => e.id));
+  const causalContext = store.allLinks().filter((l) => l.scope === "org" && l.orgId === params.orgId && (matchedIds.has(l.fromEvent) || matchedIds.has(l.toEvent)));
+  return { events: result.events, causalContext, available: true };
+}
+function predictScenarios(store, params) {
+  const horizon = params.horizon ?? 2040;
+  const maxScenarios = params.maxScenarios ?? 3;
+  const situationText = params.conditions.join(" ");
+  const resonance = historicalResonance(store, {
+    situation: situationText,
+    domains: params.domains,
+    maxResults: 5
+  });
+  const forecastEvents = store.allEvents().filter((e) => {
+    if (e.forecastConfidence === void 0)
+      return false;
+    if (e.yearNum > horizon + 10)
+      return false;
+    if (params.domains && params.domains.length > 0) {
+      if (!e.domains.some((d) => params.domains.includes(d)))
+        return false;
+    }
+    const txt = `${e.title} ${e.description} ${e.tags.join(" ")}`.toLowerCase();
+    const tokens = tokenize(situationText);
+    return tokens.some((t) => txt.includes(t)) || tokens.length === 0;
+  });
+  const scenarios = [];
+  const optimistic = forecastEvents.filter((e) => (e.forecastConfidence ?? 0) >= 0.6 && e.impactScore >= 0.7).sort((a, b) => b.impactScore - a.impactScore).slice(0, 4);
+  if (optimistic.length > 0) {
+    scenarios.push({
+      name: "Convergent Acceleration",
+      probability: avg(optimistic.map((e) => e.forecastConfidence)),
+      reasoning: `High-confidence forecasts in this domain cluster reinforce each other. Conditions (${params.conditions.join("; ")}) align with the upper-confidence band of CKG forecasts.`,
+      historicalBasis: resonance.matches.slice(0, 2).map((m) => m.insight.pattern),
+      events: optimistic
+    });
+  }
+  const cautious = forecastEvents.filter((e) => (e.forecastConfidence ?? 0) >= 0.4 && (e.forecastConfidence ?? 0) < 0.7).sort((a, b) => b.impactScore - a.impactScore).slice(0, 4);
+  if (cautious.length > 0) {
+    scenarios.push({
+      name: "Constrained Progress",
+      probability: avg(cautious.map((e) => e.forecastConfidence)),
+      reasoning: "Mid-confidence forecasts dominate this branch. Progress is real but subject to bottlenecks (regulatory, technical, economic) that historical patterns suggest cluster around tech transitions.",
+      historicalBasis: resonance.matches.slice(0, 2).map((m) => m.insight.pattern),
+      events: cautious
+    });
+  }
+  const disrupted = forecastEvents.filter((e) => (e.forecastConfidence ?? 0) < 0.5).sort((a, b) => b.impactScore - a.impactScore).slice(0, 3);
+  if (disrupted.length > 0) {
+    scenarios.push({
+      name: "Discontinuous Shift",
+      probability: 1 - avg(forecastEvents.map((e) => e.forecastConfidence) || [0.5]),
+      reasoning: "Low individual-confidence events with high impact, if realized, produce non-linear outcomes. Historically, such events (printing press, transformer architecture) were under-predicted by mainstream forecasts.",
+      historicalBasis: resonance.matches.map((m) => m.insight.pattern).slice(0, 3),
+      events: disrupted
+    });
+  }
+  return {
+    scenarios: scenarios.slice(0, maxScenarios),
+    basedOn: {
+      matchedInsights: resonance.matches.length,
+      forecastEventsConsidered: forecastEvents.length
+    }
+  };
+}
+function avg(nums) {
+  if (nums.length === 0)
+    return 0;
+  return nums.reduce((a, b) => a + b, 0) / nums.length;
+}
+
+// src/tools.ts
+var yearRangeSchema = {
+  yearFrom: {
+    type: "number",
+    description: "Inclusive start year. Negative = BCE. Example: -3500 for 3500 BCE, 1900 for 1900 CE."
+  },
+  yearTo: {
+    type: "number",
+    description: "Inclusive end year. Negative = BCE."
+  }
+};
+var domainsSchema = {
+  type: "array",
+  items: {
+    type: "string",
+    enum: ["technology", "humanities", "systems", "science", "economy", "geopolitics", "philosophy", "environment", "culture", "health", "other"]
+  },
+  description: "Filter to events in these knowledge domains."
+};
+var queryEventsT = {
+  name: "query_events",
+  description: "Search the Causari causal knowledge graph for historical events matching given criteria. Returns structured event records with title, description, year, domains, impact score, and tags. Use this when you need historical context for a topic, time period, or domain.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      ...yearRangeSchema,
+      domains: domainsSchema,
+      minImpact: {
+        type: "number",
+        minimum: 0,
+        maximum: 1,
+        description: "Filter to events with impact score >= this. Use 0.7+ for major events only."
+      },
+      query: {
+        type: "string",
+        description: "Free-text search across title, description, and tags. Case-insensitive."
+      },
+      limit: { type: "number", description: "Max events to return. Default 20.", default: 20 }
+    }
+  },
+  handler: (args, store) => {
+    const result = queryEvents(store, {
+      yearFrom: args.yearFrom,
+      yearTo: args.yearTo,
+      domains: args.domains,
+      minImpact: args.minImpact,
+      query: args.query,
+      limit: args.limit
+    });
+    return {
+      events: result.events.map((e) => ({
+        id: e.id,
+        title: e.title,
+        year: e.yearLabel,
+        yearNum: e.yearNum,
+        description: e.description,
+        domains: e.domains,
+        impactScore: e.impactScore,
+        tags: e.tags,
+        ...e.forecastConfidence !== void 0 && {
+          forecast: { confidence: e.forecastConfidence, reasoning: e.forecastReasoning }
+        }
+      })),
+      totalMatched: result.totalMatched,
+      truncated: result.truncated,
+      ...result.truncated && {
+        hint: `${result.totalMatched} events matched but only ${result.events.length} returned. Use minImpact or domains to narrow.`
+      }
+    };
+  }
+};
+var causalChainT = {
+  name: "causal_chain",
+  description: "Trace cause-effect chains from a historical event. Returns structured causal graph showing what led to the event (causes) and/or what it enabled (effects), with evidence and confidence scores. This is the most powerful Causari tool for understanding WHY something happened or what consequences flow from a development. Example: causal_chain('printing press', direction='effects', depth=2) returns the cascade from Gutenberg through Renaissance to Industrial Revolution.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      event: {
+        type: "string",
+        description: 'Event ID (e.g. "printing", "internet") or title substring (e.g. "industrial").'
+      },
+      direction: {
+        type: "string",
+        enum: ["causes", "effects", "both"],
+        description: "causes = what led to this event. effects = what flowed from it. both = full chain.",
+        default: "both"
+      },
+      depth: {
+        type: "number",
+        minimum: 1,
+        maximum: 5,
+        description: "Hops to traverse from the root event. Default 2.",
+        default: 2
+      },
+      minConfidence: {
+        type: "number",
+        minimum: 0,
+        maximum: 1,
+        description: "Filter out causal links below this confidence. Default 0 (include all)."
+      }
+    },
+    required: ["event"]
+  },
+  handler: (args, store) => {
+    const result = causalChain(store, {
+      event: args.event,
+      direction: args.direction,
+      depth: args.depth,
+      minConfidence: args.minConfidence
+    });
+    if ("notFound" in result && result.notFound) {
+      return {
+        error: `No event found matching "${result.notFound}". Try query_events first to find the right ID.`
+      };
+    }
+    const r = result;
+    return {
+      root: {
+        id: r.root.id,
+        title: r.root.title,
+        year: r.root.yearLabel,
+        description: r.root.description
+      },
+      causes: r.nodes.filter((n) => n.direction === "cause").map((n) => ({
+        id: n.event.id,
+        title: n.event.title,
+        year: n.event.yearLabel,
+        hop: n.hop,
+        relationship: n.via?.relationship,
+        confidence: n.via?.confidence,
+        evidence: n.via?.evidence
+      })),
+      effects: r.nodes.filter((n) => n.direction === "effect").map((n) => ({
+        id: n.event.id,
+        title: n.event.title,
+        year: n.event.yearLabel,
+        hop: n.hop,
+        relationship: n.via?.relationship,
+        confidence: n.via?.confidence,
+        evidence: n.via?.evidence
+      })),
+      relatedPatterns: r.relatedInsights.map((i) => ({
+        pattern: i.pattern,
+        description: i.description,
+        predictiveValue: i.predictiveValue
+      })),
+      meta: {
+        totalNodes: r.nodes.length,
+        totalLinks: r.links.length
+      }
+    };
+  }
+};
+var historicalResonanceT = {
+  name: "historical_resonance",
+  description: 'Find historical patterns similar to a current situation. Useful for understanding contemporary events through historical parallels \u2014 e.g., "rapid AI adoption displacing knowledge workers" might resonate with the printing press disrupting clergy. Returns matched patterns with exemplar historical events and predictive value scores.',
+  inputSchema: {
+    type: "object",
+    properties: {
+      situation: {
+        type: "string",
+        description: "Free-text description of the current situation, technology shift, or social pattern you want to find historical parallels for."
+      },
+      domains: domainsSchema,
+      maxResults: { type: "number", default: 3 }
+    },
+    required: ["situation"]
+  },
+  handler: (args, store) => {
+    const result = historicalResonance(store, {
+      situation: args.situation,
+      domains: args.domains,
+      maxResults: args.maxResults
+    });
+    return {
+      matches: result.matches.map((m) => ({
+        pattern: m.insight.pattern,
+        description: m.insight.description,
+        matchScore: Number(m.matchScore.toFixed(2)),
+        predictiveValue: m.insight.predictiveValue,
+        reasoning: m.reasoning,
+        exemplars: m.exemplarEvents.map((e) => ({
+          title: e.title,
+          year: e.yearLabel,
+          why: e.description.slice(0, 160)
+        }))
+      })),
+      ...result.matches.length === 0 && {
+        hint: "No strong matches. Try adding more keywords or removing domain filters."
+      }
+    };
+  }
+};
+var orgKnowledgeT = {
+  name: "org_knowledge",
+  description: "[Enterprise tier] Query the organization's internal causal knowledge graph \u2014 decisions, events, technical milestones, and their consequences. Returns events scoped to the org and the causal context linking them. Note: requires enterprise tier API key with org scope; returns empty result + message if no org graph configured.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      query: { type: "string", description: "Free-text query for org-internal events." },
+      orgId: { type: "string", description: "Organization identifier (provisioned by enterprise admin)." },
+      team: { type: "string", description: "Optional team/department filter." },
+      ...yearRangeSchema
+    },
+    required: ["query", "orgId"]
+  },
+  handler: (args, store) => {
+    return orgKnowledge(store, {
+      query: args.query,
+      orgId: args.orgId,
+      team: args.team,
+      yearFrom: args.yearFrom,
+      yearTo: args.yearTo
+    });
+  }
+};
+var predictScenariosT = {
+  name: "predict_scenarios",
+  description: "Generate plausible future scenarios based on historical causal patterns and current conditions. Returns multiple scenario branches (optimistic / cautious / discontinuous) with probability estimates, reasoning, and historical basis. Useful for strategic planning, risk assessment, and stress-testing assumptions.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      conditions: {
+        type: "array",
+        items: { type: "string" },
+        description: 'List of current conditions or trends. e.g., ["AI capability accelerating", "open-source LLMs improving"].'
+      },
+      horizon: {
+        type: "number",
+        description: "Year horizon for scenarios. Default 2040.",
+        default: 2040
+      },
+      domains: domainsSchema,
+      maxScenarios: { type: "number", default: 3 }
+    },
+    required: ["conditions"]
+  },
+  handler: (args, store) => {
+    const result = predictScenarios(store, {
+      conditions: args.conditions,
+      horizon: args.horizon,
+      domains: args.domains,
+      maxScenarios: args.maxScenarios
+    });
+    return {
+      scenarios: result.scenarios.map((s) => ({
+        name: s.name,
+        probability: Number(s.probability.toFixed(2)),
+        reasoning: s.reasoning,
+        historicalBasis: s.historicalBasis,
+        keyEvents: s.events.map((e) => ({
+          title: e.title,
+          year: e.yearLabel,
+          forecastConfidence: e.forecastConfidence,
+          description: e.description
+        }))
+      })),
+      meta: {
+        ...result.basedOn,
+        disclaimer: "Scenarios are derived from historical pattern matching, not guaranteed forecasts. Confidence reflects internal CKG calibration only."
+      }
+    };
+  }
+};
+var ALL_TOOLS = [
+  queryEventsT,
+  causalChainT,
+  historicalResonanceT,
+  orgKnowledgeT,
+  predictScenariosT
+];
+
+export {
+  CKGStore,
+  loadSeed,
+  ALL_TOOLS
+};