data.jsx

/* DBLingo — content data
 * Six worlds × multiple levels. Each level declares its `kind`:
 *   - "shape"   → drag fields into a JSON document shape
 *   - "blocks"  → drag operator/value tokens into snippet slots
 *   - "reorder" → drag pipeline stages into the right order
 *   - "index"   → drag index types onto fields of a collection
 *   - "fill"    → click-to-fill blanks from a choice bank
 * Each level also carries its prompt, the source for the live preview pane,
 * a "why this works" concept blurb, and the correct-answer key.
 */

const HINTS = /*EDITMODE-BEGIN*/{
  "$match":        "Filters docs against a condition — like a WHERE clause.",
  "$group":        "Groups docs by a key and accumulates totals.",
  "$project":      "Reshapes each doc: include, rename, or compute fields.",
  "$lookup":       "Joins another collection by matching a foreign key.",
  "$unwind":       "Explodes an array field into one doc per element.",
  "$sort":         "Orders results by one or more fields.",
  "$limit":        "Returns only the first N docs after sort.",
  "$search":       "Atlas Search stage for full-text search inside aggregate().",
  "$eq":           "Matches exactly equal values.",
  "$gt":           "Greater than. ($gte for inclusive.)",
  "$lt":           "Less than. ($lte for inclusive.)",
  "$in":           "Matches any value in an array.",
  "$text":         "Full-text search across indexed string fields.",
  "$vectorSearch": "Atlas-only stage: k-NN search over a vector index.",
  "find":          "Returns matching documents from a collection.",
  "insertOne":     "Inserts a single document, returns its _id.",
  "updateOne":     "Updates the first matching doc with a `$set` patch.",
  "deleteOne":     "Deletes the first matching doc.",
  "explain":       "Shows how MongoDB ran a query: which index it used (if any) and how many docs it read.",
  "executionStats": "explain() mode that actually runs the query and reports docs/keys examined and time taken.",
  "IXSCAN":        "Index scan: MongoDB walks an index to jump straight to matching docs. Fast.",
  "COLLSCAN":      "Collection scan: no usable index, so MongoDB reads every document. Slow on big collections.",
  "createIndex":   "Builds an index on one or more fields. Reads get fast.",
  "watch":         "Opens a change stream cursor for inserts, updates, deletes, and replaces.",
  "$source":       "Atlas Stream Processing stage that reads from a streaming source.",
  "$merge":        "Writes aggregation or stream output into a target collection.",
  "TTL":           "Time-To-Live: docs expire automatically after N seconds.",
  "ESR":           "Equality → Sort → Range. Compound-index field order rule.",
  "covered":       "All projected fields live in the index — no fetch needed.",
  "compound":      "Index across multiple fields. Order matters (ESR)."
}/*HINTS-END*/;

const LEVEL_HINTS = {
  d1: [
    'Match each field to the BSON/JSON shape the document expects: string, number, array, or embedded document.',
    'Strings need quotes; numbers do not. Arrays use [ ], and embedded documents use { }.'
  ],
  d2: [
    'Find the collection name first, then choose the MongoDB write operation.',
    'insertOne() writes exactly one document object and returns an inserted _id.'
  ],
  d3: [
    'Use $set when you want to patch fields without replacing the whole document.',
    'The first argument finds the document; the second argument describes the update.'
  ],
  d4: [
    'Use deleteOne when the task asks to remove exactly one matching document.',
    'If a sort is present, it decides which matching document is removed first.'
  ],
  q1: [
    'Equality queries match a field directly to one value.',
    'The filter shape is { field: value }; string values need quotes.'
  ],
  q2: [
    '$match is the aggregation stage that filters documents.',
    'Use $gt for “greater than”; keep numeric thresholds as numbers, not strings.'
  ],
  q3: [
    '$in expects an array of possible values.',
    'Use $in when one field can match any value from a list.'
  ],
  q4: [
    'MongoDB implicitly ANDs conditions listed in the same filter object.',
    'Use range operators like $gte/$lte or $gt/$lt inside the field condition.'
  ],
  a1: [
    'Filter early to reduce how much data later stages process.',
    'Group before sorting when the sort depends on an aggregated value.'
  ],
  a2: [
    '$project controls the output shape returned by the pipeline.',
    'Use _id: 0 to hide MongoDB’s default _id field when the UI does not need it.'
  ],
  a3: [
    '$lookup attaches matching documents from another collection as an array.',
    'Use $unwind after $lookup when you want one joined object instead of an array.'
  ],
  a4: [
    '$sort chooses the order; $limit chooses how many results remain.',
    'For newest or highest first, descending sort usually uses -1.'
  ],
  i1: [
    'Pick the index based on the whole query pattern, not just the field name.',
    'Text search belongs to Atlas Search; low-cardinality booleans often should not be indexed alone.'
  ],
  i2: [
    'ESR means Equality fields first, then Sort fields, then Range fields.',
    'Range predicates like $gt/$lt usually come after equality and sort keys in the compound index.'
  ],
  i3: [
    'TTL indexes require a date field and expireAfterSeconds.',
    'Convert days or hours into seconds before filling the TTL value.'
  ],
  i4: [
    'A covered query projects only fields that exist in the index.',
    'Exclude _id with _id: 0 unless _id is also part of the index.'
  ],
  v1: [
    '$vectorSearch needs the indexed vector path and a numeric limit.',
    'The query vector comes from an embedding model; Atlas returns nearest neighbors.'
  ],
  v2: [
    'Atlas Search runs inside aggregate() as a $search stage.',
    'Use the text operator with a path and query for full-text matching.'
  ],
  v3: [
    'A trigger watches one collection for specific operation types.',
    'The function name should be a string reference to the server-side handler.'
  ],
  v4: [
    'For RAG, retrieve relevant records first, then trim the payload for the LLM.',
    'Use filters to keep retrieval scoped to the right tenant, store, org, or domain.'
  ],
  s1: [
    'watch() opens a change stream; filter operationType to only react to inserts, updates, deletes, or replaces.',
    'Change stream events include operationType plus fullDocument when configured for inserts and updates.'
  ],
  s2: [
    'Filter change events on fullDocument fields so only meaningful business events flow downstream.',
    'Use numeric thresholds as numbers, not strings.'
  ],
  s3: [
    'Stream processors usually read from a source, filter early, project the event shape, then write or route the result.',
    'Keep only the fields the downstream alert, dashboard, or workflow needs.'
  ],
  s4: [
    'Route processed events into an operational collection or handler that downstream apps can consume.',
    'Real-time pipelines should be idempotent because events can be retried.'
  ]
};

/* Official-docs "Learn more" links shown in each level's "Why does this work?"
 * card. Keyed by the shared level IDs so every pack inherits them; a level can
 * override with its own `docs: [{ label, url }]`. */
const MDB_DOCS = 'https://www.mongodb.com/docs';
const LEVEL_DOCS = {
  d1: [{ label: 'Documents', url: MDB_DOCS + '/manual/core/document/' }],
  d2: [{ label: 'insertOne()', url: MDB_DOCS + '/manual/reference/method/db.collection.insertone/' }],
  d3: [
    { label: 'updateOne()', url: MDB_DOCS + '/manual/reference/method/db.collection.updateone/' },
    { label: '$set', url: MDB_DOCS + '/manual/reference/operator/update/set/' }
  ],
  d4: [{ label: 'deleteOne()', url: MDB_DOCS + '/manual/reference/method/db.collection.deleteone/' }],
  q1: [{ label: 'Query documents', url: MDB_DOCS + '/manual/tutorial/query-documents/' }],
  q2: [
    { label: '$match', url: MDB_DOCS + '/manual/reference/operator/aggregation/match/' },
    { label: '$gt', url: MDB_DOCS + '/manual/reference/operator/query/gt/' }
  ],
  q3: [{ label: '$in', url: MDB_DOCS + '/manual/reference/operator/query/in/' }],
  q4: [{ label: '$and', url: MDB_DOCS + '/manual/reference/operator/query/and/' }],
  a1: [
    { label: 'Aggregation pipeline', url: MDB_DOCS + '/manual/core/aggregation-pipeline/' },
    { label: '$group', url: MDB_DOCS + '/manual/reference/operator/aggregation/group/' }
  ],
  a2: [{ label: '$project', url: MDB_DOCS + '/manual/reference/operator/aggregation/project/' }],
  a3: [
    { label: '$lookup', url: MDB_DOCS + '/manual/reference/operator/aggregation/lookup/' },
    { label: '$unwind', url: MDB_DOCS + '/manual/reference/operator/aggregation/unwind/' }
  ],
  a4: [
    { label: '$sort', url: MDB_DOCS + '/manual/reference/operator/aggregation/sort/' },
    { label: '$limit', url: MDB_DOCS + '/manual/reference/operator/aggregation/limit/' }
  ],
  i1: [
    { label: 'Indexes', url: MDB_DOCS + '/manual/indexes/' },
    { label: 'Explain results (IXSCAN, COLLSCAN)', url: MDB_DOCS + '/manual/reference/explain-results/' }
  ],
  i2: [
    { label: 'The ESR guideline', url: MDB_DOCS + '/manual/tutorial/equality-sort-range-guideline/' },
    { label: 'Compound indexes', url: MDB_DOCS + '/manual/core/indexes/index-types/index-compound/' }
  ],
  i3: [{ label: 'TTL indexes', url: MDB_DOCS + '/manual/core/index-ttl/' }],
  i4: [
    { label: 'explain()', url: MDB_DOCS + '/manual/reference/method/cursor.explain/' },
    { label: 'Reading explain results', url: MDB_DOCS + '/manual/reference/explain-results/' },
    { label: 'Covered queries', url: MDB_DOCS + '/manual/core/query-optimization/' }
  ],
  v1: [{ label: '$vectorSearch', url: MDB_DOCS + '/vector-search/query/aggregation-stages/vector-search-stage/' }],
  v2: [{ label: '$search', url: MDB_DOCS + '/search/query/aggregation-stages/search/' }],
  v3: [{ label: 'Database triggers', url: MDB_DOCS + '/atlas/atlas-ui/triggers/database-triggers/' }],
  v4: [{ label: 'RAG with Vector Search', url: MDB_DOCS + '/vector-search/tutorials/rag/' }],
  s1: [{ label: 'Change streams', url: MDB_DOCS + '/manual/changestreams/' }],
  s2: [{ label: 'Change streams', url: MDB_DOCS + '/manual/changestreams/' }],
  s3: [
    { label: 'Atlas Stream Processing', url: MDB_DOCS + '/atlas/atlas-stream-processing/' },
    { label: '$source', url: MDB_DOCS + '/atlas/atlas-stream-processing/sp-agg-source/' }
  ],
  s4: [{ label: '$merge (stream processing)', url: MDB_DOCS + '/atlas/atlas-stream-processing/sp-agg-merge/' }]
};

/* Optional next steps shown when a learner completes every level in a world,
 * and re-openable from the world banner on the map afterwards.
 * Keyed by the shared world IDs so every learning pack (which clones WORLDS)
 * gets the same topical recommendations. `type` defaults to 'Skill Badge';
 * set it for anything else (e.g. a full course) so the UI labels it honestly. */
const SKILL_BADGES_HOME = 'https://learn.mongodb.com/skills';
const GENAI_PATH = 'https://learn.mongodb.com/learning-paths/mongodb-genai-developer';

const WORLD_SKILL_BADGES = {
  docs: [
    { title: 'Relational to Document Model', url: 'https://learn.mongodb.com/courses/relational-to-document-model' },
    { title: 'Schema Design Patterns and Anti-patterns', url: 'https://learn.mongodb.com/courses/schema-design-patterns-and-antipatterns' },
    { title: 'Advanced Schema Patterns and Anti-patterns', url: 'https://learn.mongodb.com/courses/advanced-schema-patterns-and-antipatterns' },
    { title: 'Schema Design Optimization', url: 'https://learn.mongodb.com/courses/schema-design-optimization' }
  ],
  query: [
    { title: 'CRUD Operations', url: 'https://learn.mongodb.com/courses/crud-operations-in-mongodb' }
  ],
  agg: [
    { title: 'Fundamentals of Data Transformation', url: 'https://learn.mongodb.com/courses/fundamentals-of-data-transformation' }
  ],
  idx: [
    { title: 'Query Optimization', url: 'https://learn.mongodb.com/courses/query-optimization' }
  ],
  atlas: [
    { title: 'AI Data Strategy with MongoDB', url: 'https://learn.mongodb.com/courses/ai-data-strategy-with-mongodb' },
    { title: 'Building an App with Code Agents and MongoDB', url: 'https://learn.mongodb.com/courses/building-an-app-with-code-agents-and-mongodb' },
    // No public per-badge URL found for these two; they live in the GenAI Developer path.
    { title: 'Vector Search Fundamentals', url: GENAI_PATH },
    { title: 'RAG with MongoDB', url: GENAI_PATH },
    { title: 'AI Agents with MongoDB', url: 'https://learn.mongodb.com/courses/ai-agents-with-mongodb' },
    { title: 'Memory for AI Applications with MongoDB', url: SKILL_BADGES_HOME }
  ],
  streams: [
    { title: 'Atlas Stream Processing', url: 'https://learn.mongodb.com/courses/atlas-stream-processing', type: 'Course' }
  ]
};

const WORLDS = [
  /* ============================================================ WORLD 1 */
  {
    id: 'docs',
    icon: 'leaf',
    name: 'Documents & Collections',
    tagline: 'Shape your data',
    blurb: 'JSON-shaped documents, organized into collections. Where MongoDB begins.',
    tint: 'rgba(0,237,100,0.18)',
    tintSolid: '#00ED64',
    levels: [
      {
        id: 'd1', title: 'Build a user document', kind: 'shape',
        prompt: 'Drag the right values into the user document for Ada Lovelace.',
        sub:    'Documents can combine strings and numbers with arrays and embedded documents.',
        why:    'A MongoDB document is BSON — JSON with extra types (ObjectId, Date, Decimal128). Related values can live together as arrays and embedded documents, matching the application object without joins.',
        skeleton: [
          { key: '_id',    type: 'oid',   value: 'ObjectId("64e...")' },
          { key: 'name',   type: 'slot',  slot: 'name'   },
          { key: 'age',    type: 'slot',  slot: 'age'    },
          { key: 'skills', type: 'slot',  slot: 'skills' },
          { key: 'preferences', type: 'slot', slot: 'preferences' }
        ],
        bank: [
          { id: 'name',    label: '"Ada Lovelace"',           kind: 'value' },
          { id: 'age',     label: '36',                       kind: 'value' },
          { id: 'skills',  label: '["math", "programming"]', kind: 'value' },
          { id: 'preferences', label: '{ theme: "dark", digest: "weekly" }', kind: 'value' },
          /* distractors */
          { id: 'd1',      label: '"36"',                     kind: 'value' },
          { id: 'd2',      label: 'Ada Lovelace',             kind: 'value' },
          { id: 'd3',      label: '[math, "programming"]',   kind: 'value' }
        ],
        answer: { name: 'name', age: 'age', skills: 'skills', preferences: 'preferences' }
      },
      {
        id: 'd2', title: 'insertOne()', kind: 'blocks',
        prompt: 'Insert a new product into the `products` collection. Drag the missing pieces.',
        sub:    'insertOne() takes a single document and returns its generated _id.',
        why:    '`insertOne()` is the simplest write. For many docs, use `insertMany()`. MongoDB auto-generates an `_id` if you don\'t provide one.',
        snippet: [
          'db.', { slot: 'col' }, '.', { slot: 'op' }, '({',
          '\n  name: ', { slot: 'val' }, ',',
          '\n  price: 24.99,',
          '\n  inStock: ', { slot: 'bool' },
          '\n})'
        ],
        bank: [
          { id: 'op',   label: 'insertOne', kind: 'op',    answer: 'op'   },
          { id: 'col',  label: 'products',  kind: 'field', answer: 'col'  },
          { id: 'val',  label: '"Espresso"', kind: 'value', answer: 'val' },
          { id: 'bool', label: 'true',      kind: 'value', answer: 'bool' },
          /* distractors */
          { id: 'x1',   label: 'addOne',    kind: 'op'    },
          { id: 'x2',   label: 'inventory', kind: 'field' },
          { id: 'x3',   label: 'Espresso',  kind: 'value' }
        ]
      },
      {
        id: 'd3', title: 'updateOne()', kind: 'fill',
        prompt: 'Mark order #1042 as shipped.',
        sub:    'Use the $set operator to change one or more fields in place.',
        why:    'Without `$set` you would *replace* the entire doc. `$set` patches only the listed fields and leaves the rest alone.',
        snippet: [
          'db.orders.updateOne(',
          '\n  { orderId: 1042 },',
          '\n  { ', { blank: 'op' }, ': { ', { blank: 'field' }, ': ', { blank: 'val' }, ' } }',
          '\n)'
        ],
        choices: {
          op:    { options: ['$set', '$push', '$inc', '$replace'], answer: '$set' },
          field: { options: ['status', 'state', 'shipped', 'flag'], answer: 'status' },
          val:   { options: ['"shipped"', 'shipped', 'true', '1'],  answer: '"shipped"' }
        }
      },
      {
        id: 'd4', title: 'deleteOne()', kind: 'fill',
        prompt: 'Remove the cancelled order with the highest id.',
        sub:    'deleteOne() removes the first doc that matches — no second chances.',
        why:    'Filter precision matters: a too-broad filter on `deleteMany()` is the classic MongoDB foot-gun. Always preview with `find()` first.',
        snippet: [
          'db.orders.', { blank: 'op' }, '(',
          '\n  { status: ', { blank: 'val' }, ' },',
          '\n  { sort: { orderId: ', { blank: 'dir' }, ' } }',
          '\n)'
        ],
        choices: {
          op:  { options: ['deleteOne', 'removeOne', 'dropOne'], answer: 'deleteOne' },
          val: { options: ['"cancelled"', 'cancelled', 'null'],   answer: '"cancelled"' },
          dir: { options: ['-1', '1', '"desc"'],                  answer: '-1' }
        }
      }
    ]
  },

  /* ============================================================ WORLD 2 */
  {
    id: 'query',
    icon: 'magnify',
    name: 'Querying',
    tagline: 'Ask the database questions',
    blurb: 'find() and the operator family: $eq, $gt, $lt, $in, $and, $or.',
    tint: 'rgba(1,107,248,0.22)',
    tintSolid: '#4DA3FF',
    levels: [
      {
        id: 'q1', title: 'Equality with find()', kind: 'blocks',
        prompt: 'Find every user whose role is "admin".',
        sub:    'For equality, you can write the value directly — $eq is implicit.',
        why:    'When you write `{ field: value }`, Mongo treats it as `$eq`. Explicit `$eq` is only required inside larger expressions.',
        snippet: [
          'db.users.find({ ',
          { slot: 'field' }, ': ', { slot: 'val' },
          ' })'
        ],
        bank: [
          { id: 'field', label: 'role',     kind: 'field', answer: 'field' },
          { id: 'val',   label: '"admin"',  kind: 'value', answer: 'val'   },
          /* distractors */
          { id: 'x1',    label: 'roles',    kind: 'field' },
          { id: 'x2',    label: 'admin',    kind: 'value' },
          { id: 'x3',    label: 'isAdmin',  kind: 'field' }
        ]
      },
      {
        id: 'q2', title: '$gt with $match', kind: 'blocks',
        prompt: 'Find orders over $100. Drag the operator and value.',
        sub:    'In aggregation, you wrap conditions in $match. Operators start with $.',
        why:    '$match early in a pipeline lets the planner push the filter down to an index — same speed as a regular `find()`.',
        snippet: [
          'db.orders.aggregate([',
          '\n  { ', { slot: 'stage' }, ': { total: { ', { slot: 'op' }, ': ', { slot: 'val' }, ' } } }',
          '\n])'
        ],
        bank: [
          { id: 'stage', label: '$match', kind: 'stage', answer: 'stage' },
          { id: 'op',    label: '$gt',    kind: 'op',    answer: 'op'    },
          { id: 'val',   label: '100',    kind: 'value', answer: 'val'   },
          /* distractors */
          { id: 'x1',    label: '$where', kind: 'stage' },
          { id: 'x2',    label: '$eq',    kind: 'op'    },
          { id: 'x3',    label: '$lt',    kind: 'op'    },
          { id: 'x4',    label: '"100"',  kind: 'value' }
        ]
      },
      {
        id: 'q3', title: '$in — multi-value match', kind: 'fill',
        prompt: 'Find products in the "coffee" or "tea" categories.',
        sub:    '$in matches if a field equals any value in the array.',
        why:    '`$in` is shorthand for an `$or` of equality checks. It uses indexes efficiently — prefer it over a string of `$or`s.',
        snippet: [
          'db.products.find({',
          '\n  category: { ', { blank: 'op' }, ': ', { blank: 'arr' }, ' }',
          '\n})'
        ],
        choices: {
          op:  { options: ['$in', '$any', '$or', '$contains'], answer: '$in' },
          arr: {
            options: ['["coffee", "tea"]', '"coffee, tea"', '{ coffee, tea }', '[coffee, tea]'],
            answer: '["coffee", "tea"]'
          }
        }
      },
      {
        id: 'q4', title: 'Compound filter', kind: 'fill',
        prompt: 'Find active users aged 18–25.',
        sub:    'Combine equality and range operators in one filter object.',
        why:    'When all conditions are on different fields, just list them — Mongo ANDs them implicitly. No need for explicit `$and`.',
        snippet: [
          'db.users.find({',
          '\n  active: true,',
          '\n  age: { ', { blank: 'gte' }, ': 18, ', { blank: 'lte' }, ': 25 }',
          '\n})'
        ],
        choices: {
          gte: { options: ['$gte', '$gt', '$geq', '>='], answer: '$gte' },
          lte: { options: ['$lte', '$lt', '$leq', '<='], answer: '$lte' }
        }
      }
    ]
  },

  /* ============================================================ WORLD 3 */
  {
    id: 'agg',
    icon: 'diagram',
    name: 'Aggregation Pipeline',
    tagline: 'Compose data transformations',
    blurb: 'Stack stages like a UNIX pipe. Each stage feeds the next.',
    tint: 'rgba(255,192,16,0.20)',
    tintSolid: '#FFC76A',
    levels: [
      {
        id: 'a1', title: 'Order matters', kind: 'reorder',
        collection: 'orders', // shown in the solved-query preview
        prompt: 'Total revenue per customer in 2024 — re-order the stages.',
        sub:    'Filter early, group, sort, then limit. The ESR of pipelines.',
        why:    'Put `$match` first so the planner can use indexes and shrink the dataset before the expensive `$group`. Sort after grouping; limit last.',
        stages: [
          { id: 'm', code: '$match: { year: 2024 }', sub: 'filter to 2024 docs',          correct: 0 },
          { id: 'g', code: '$group: { _id: "$customer", total: { $sum: "$amount" } }', sub: 'sum amounts per customer', correct: 1 },
          { id: 's', code: '$sort: { total: -1 }',     sub: 'highest spenders first',     correct: 2 },
          { id: 'l', code: '$limit: 5',                sub: 'top 5 only',                  correct: 3 }
        ],
        // initial scramble
        initial: ['s', 'l', 'm', 'g']
      },
      {
        id: 'a2', title: '$project — reshape output', kind: 'fill',
        prompt: 'Return just the customer name and order total.',
        sub:    '$project picks (and renames or computes) fields per doc.',
        why:    '`1` includes a field, `0` excludes it. `_id` is the only field included by default — disable it explicitly when you don\'t want it.',
        snippet: [
          'db.orders.aggregate([',
          '\n  { $project: {',
          '\n    _id: ', { blank: 'id' }, ',',
          '\n    customer: ', { blank: 'one' }, ',',
          '\n    total: ', { blank: 'one2' },
          '\n  } }',
          '\n])'
        ],
        choices: {
          id:   { options: ['0', '1', 'false', 'null'], answer: '0' },
          one:  { options: ['1', '0', 'true', '"yes"'], answer: '1' },
          one2: { options: ['1', '0', '"$total"', 'yes'], answer: '1' }
        }
      },
      {
        id: 'a3', title: '$lookup — join collections', kind: 'reorder',
        collection: 'orders', // shown in the solved-query preview
        prompt: 'Attach each order\'s customer doc, then keep only the name.',
        sub:    '$lookup adds an array of matches. $unwind flattens it. $project finishes the shape.',
        why:    '`$lookup` is your JOIN. It returns an array — even for single matches — so `$unwind` is almost always next.',
        stages: [
          { id: 'lo', code: '$lookup: { from: "customers", localField: "customerId", foreignField: "_id", as: "cust" }', sub: 'attach customer docs as array', correct: 0 },
          { id: 'un', code: '$unwind: "$cust"',                       sub: 'one doc per match',         correct: 1 },
          { id: 'pr', code: '$project: { _id: 0, name: "$cust.name" }', sub: 'keep only the name',     correct: 2 }
        ],
        initial: ['pr', 'lo', 'un']
      },
      {
        id: 'a4', title: '$sort + $limit', kind: 'blocks',
        prompt: 'Show the three most recent posts.',
        sub:    'Sort descending by createdAt, then keep three.',
        why:    'When `$sort` is followed by `$limit`, the engine streams just enough docs through the sort — much cheaper than sorting the whole collection.',
        snippet: [
          'db.posts.aggregate([',
          '\n  { ', { slot: 'sort' }, ': { createdAt: ', { slot: 'dir' }, ' } },',
          '\n  { ', { slot: 'limit' }, ': ', { slot: 'n' }, ' }',
          '\n])'
        ],
        bank: [
          { id: 'sort',  label: '$sort',  kind: 'stage', answer: 'sort'  },
          { id: 'limit', label: '$limit', kind: 'stage', answer: 'limit' },
          { id: 'dir',   label: '-1',     kind: 'value', answer: 'dir'   },
          { id: 'n',     label: '3',      kind: 'value', answer: 'n'     },
          /* distractors */
          { id: 'x1',    label: '$top',   kind: 'stage' },
          { id: 'x2',    label: '$first', kind: 'stage' },
          { id: 'x3',    label: '1',      kind: 'value' },
          { id: 'x4',    label: '"3"',    kind: 'value' }
        ]
      }
    ]
  },

  /* ============================================================ WORLD 4 */
  {
    id: 'idx',
    icon: 'database',
    name: 'Indexes & Performance',
    tagline: 'Make queries fast',
    blurb: 'The ESR rule, covered queries, and TTL indexes.',
    tint: 'rgba(94,12,158,0.30)',
    tintSolid: '#C390DF',
    levels: [
      {
        id: 'i1', title: 'Classify index choices', kind: 'index',
        prompt: 'The `events` collection has four query shapes. Pick the best index strategy for each one.',
        sub:    'Classify the full query shape: one equality field, equality+sort fields, Atlas Search text, or no index.',
        why:    'Indexes trade write cost for read speed. A compound index must include every field needed by that query shape — for example `{ userId: 1, createdAt: -1 }` supports filtering by userId and sorting by createdAt. In `explain()` output, a good index shows up as `IXSCAN` (index scan); a missing one as `COLLSCAN` (MongoDB reads every document).',
        collection: 'events',
        fields: [
          { name: 'userId',             type: 'ObjectId', need: 'single', used: 'db.events.find({ userId })'  },
          { name: 'userId + createdAt', type: 'ObjectId + Date', need: 'compound', used: 'db.events.find({ userId }).sort({ createdAt: -1 })' },
          { name: 'title',              type: 'String', need: 'search', used: 'Atlas Search text query on event titles' },
          { name: 'isInternal',         type: 'Bool', need: 'none', used: 'low cardinality flag — usually do not index alone' }
        ],
        bank: [
          { id: 'single',   label: 'Single-field', kind: 'index' },
          { id: 'compound', label: 'Compound',     kind: 'index' },
          { id: 'search',   label: 'Atlas Search', kind: 'index' },
          { id: 'none',     label: 'No index',     kind: 'index' }
        ]
      },
      {
        id: 'i2', title: 'The ESR rule', kind: 'reorder',
        prompt: 'Put the fields of this compound index in ESR order: Equality, Sort, Range.',
        sub:    'For: db.orders.find({ status: "paid", amount: { $gt: 50 } }).sort({ createdAt: -1 })',
        why:    'ESR: index Equality fields first (smallest sub-tree), then the Sort key (so the index returns rows pre-sorted), then Range (which forces a scan inside the bucket).',
        stages: [
          { id: 'e', code: 'status: 1',     sub: 'filter: { status: "paid" }', correct: 0 },
          { id: 's', code: 'createdAt: -1', sub: '.sort({ createdAt: -1 })', correct: 1 },
          { id: 'r', code: 'amount: 1',     sub: 'filter: { amount: { $gt: 50 } }',           correct: 2 }
        ],
        initial: ['r', 's', 'e']
      },
      {
        id: 'i3', title: 'TTL index', kind: 'fill',
        prompt: 'Expire session docs 24 hours after `lastSeen`.',
        sub:    'Add expireAfterSeconds to a date-typed field index.',
        why:    'TTL indexes are checked by a background thread once per minute. Don\'t use them for precise timing — expect drift of up to 60s.',
        snippet: [
          'db.sessions.', { blank: 'op' }, '(',
          '\n  { lastSeen: 1 },',
          '\n  { ', { blank: 'key' }, ': ', { blank: 'sec' }, ' }',
          '\n)'
        ],
        choices: {
          op:  { options: ['createIndex', 'addIndex', 'index', 'ensureIndex'], answer: 'createIndex' },
          key: { options: ['expireAfterSeconds', 'ttl', 'expires', 'maxAge'],   answer: 'expireAfterSeconds' },
          sec: { options: ['86400', '24', '1440', '3600'],                       answer: '86400' }
        }
      },
      {
        id: 'i4', title: 'Covered query', kind: 'fill',
        prompt: 'Project only fields that live inside the index { sku: 1, price: 1 }.',
        sub:    'When every projected field is in the index, MongoDB skips the document fetch.',
        why:    'A *covered* query returns from the index alone — no disk seek. `explain()` reports how MongoDB ran a query; in `"executionStats"` mode it also counts what it read. `totalDocsExamined: 0` means the answer came straight from the index without touching a single document.',
        snippet: [
          'db.products.find(',
          '\n  { sku: ', { blank: 'val' }, ' },',
          '\n  { _id: ', { blank: 'id' }, ', sku: 1, price: 1 }',
          '\n).', { blank: 'verb' }, '("executionStats")'
        ],
        choices: {
          val:  { options: ['"ESPRESSO-01"', 'ESPRESSO-01', '*', '{}'],  answer: '"ESPRESSO-01"' },
          id:   { options: ['0', '1', 'null', 'true'],                   answer: '0' },
          verb: { options: ['explain', 'plan', 'analyze', 'trace'],      answer: 'explain' }
        }
      }
    ]
  },

  /* ============================================================ WORLD 5 */
  {
    id: 'atlas',
    icon: 'cloud',
    name: 'Atlas Superpowers',
    tagline: 'Vector, search, triggers',
    blurb: 'The pieces that turn MongoDB into a modern AI data platform.',
    tint: 'rgba(0,237,100,0.22)',
    tintSolid: '#71F6BA',
    levels: [
      {
        id: 'v1', title: '$vectorSearch', kind: 'fill',
        prompt: 'Find the 5 nearest products to a query embedding.',
        sub:    'Atlas Vector Search runs k-NN against an HNSW index you created on `embedding`.',
        why:    'Vector search powers RAG. Generate the embedding from your LLM, pass it as `queryVector`, and Atlas returns the closest docs by cosine distance.',
        snippet: [
          'db.products.aggregate([{',
          '\n  $vectorSearch: {',
          '\n    index: "embed_idx",',
          '\n    path: ', { blank: 'path' }, ',',
          '\n    queryVector: queryEmbedding,',
          '\n    numCandidates: 150,',
          '\n    ', { blank: 'limit' }, ': 5',
          '\n  }',
          '\n}])'
        ],
        choices: {
          path:  { options: ['"embedding"', '"vector"', 'embedding', '*'], answer: '"embedding"' },
          limit: { options: ['limit', 'numResults', 'topK', 'k'],          answer: 'limit' }
        }
      },
      {
        id: 'v2', title: '$search — Atlas Search', kind: 'blocks',
        prompt: 'Use Atlas Search to find blog posts mentioning "aggregation pipeline".',
        sub:    'Atlas Search runs as a `$search` stage inside `aggregate()`, not as `find({ $text: ... })`.',
        why:    'Atlas Search uses a dedicated search index and the `$search` aggregation stage. It supports relevance scoring, analyzers, fuzzy matching, highlighting, autocomplete, and richer production search patterns than legacy `$text`.',
        snippet: [
          'db.posts.aggregate([',
          '\n  { ', { slot: 'stage' }, ': {',
          '\n    ', { slot: 'operator' }, ': {',
          '\n      path: ', { slot: 'path' }, ',',
          '\n      query: ', { slot: 'query' },
          '\n    }',
          '\n  } }',
          '\n])'
        ],
        bank: [
          { id: 'stage',    label: '$search',       kind: 'stage', answer: 'stage' },
          { id: 'operator', label: 'text',          kind: 'op',    answer: 'operator' },
          { id: 'path',     label: '"body"',        kind: 'field', answer: 'path' },
          { id: 'query',    label: '"aggregation pipeline"', kind: 'value', answer: 'query' },
          /* distractors */
          { id: 'x1',  label: '$text',         kind: 'op'    },
          { id: 'x2',  label: 'find',          kind: 'op'    },
          { id: 'x3',  label: 'aggregation pipeline', kind: 'value' }
        ]
      },
      {
        id: 'v3', title: 'Atlas Trigger', kind: 'fill',
        prompt: 'Send a welcome email whenever a user is inserted.',
        sub:    'Triggers run server-side on change events. Pick the event type and the collection.',
        why:    'Triggers attach to a change stream. Keep handlers small (<60s) and idempotent — they can re-fire.',
        snippet: [
          '// Atlas Trigger config',
          '\n{',
          '\n  type: "DATABASE",',
          '\n  database: "app",',
          '\n  collection: ', { blank: 'col' }, ',',
          '\n  operationTypes: [', { blank: 'evt' }, '],',
          '\n  function: ', { blank: 'fn' },
          '\n}'
        ],
        choices: {
          col: { options: ['"users"', 'users', 'User', '*'],                          answer: '"users"' },
          evt: { options: ['"insert"', '"create"', '"write"', '"new"'],               answer: '"insert"' },
          fn:  { options: ['"sendWelcomeEmail"', 'sendWelcomeEmail', 'fn()', 'send()'], answer: '"sendWelcomeEmail"' }
        }
      },
      {
        id: 'v4', title: 'RAG: hybrid retrieval', kind: 'reorder',
        collection: 'documents', // shown in the solved-query preview
        prompt: 'Pipeline for retrieval-augmented chat: filter by tenant, vector-search, then trim payload.',
        sub:    '$match early (tenant scope) → $vectorSearch (semantic) → $project (keep only what the LLM needs).',
        why:    'Tenant filters belong before semantic search so you only rank documents the user is allowed to see. Always trim the payload — every token costs.',
        stages: [
          { id: 'vs', code: '$vectorSearch: { index: "embed", path: "embedding", queryVector: q, limit: 8, filter: { tenantId } }', sub: 'k-NN with tenant prefilter', correct: 0 },
          { id: 'ms', code: '$match: { score: { $gt: 0.78 } }', sub: 'drop weak matches',  correct: 1 },
          { id: 'pj', code: '$project: { _id: 0, title: 1, chunk: 1, score: { $meta: "vectorSearchScore" } }', sub: 'trim for the LLM', correct: 2 }
        ],
        initial: ['pj', 'ms', 'vs']
      }
    ]
  },

  /* ============================================================ WORLD 6 */
  {
    id: 'streams',
    icon: 'sparkle',
    name: 'Real-Time Streams',
    tagline: 'React as data changes',
    blurb: 'Change Streams and Atlas Stream Processing turn operational writes into live workflows.',
    tint: 'rgba(113,246,186,0.16)',
    tintSolid: '#00ED64',
    levels: [
      {
        id: 's1', title: 'Change Stream — watch inserts', kind: 'blocks',
        prompt: 'Watch for new operational events as they are inserted.',
        sub:    'Change streams let apps react to writes without polling.',
        why:    'Change streams expose MongoDB writes as an ordered event stream. Apps can subscribe once and react to inserts, updates, replaces, and deletes in real time.',
        snippet: [
          'db.', { slot: 'col' }, '.watch([',
          '\n  { ', { slot: 'stage' }, ': { operationType: ', { slot: 'evt' }, ' } }',
          '\n])'
        ],
        bank: [
          { id: 'col',   label: 'events',    kind: 'field', answer: 'col' },
          { id: 'stage', label: '$match',    kind: 'stage', answer: 'stage' },
          { id: 'evt',   label: '"insert"',  kind: 'value', answer: 'evt' },
          { id: 'x1',    label: 'listen',    kind: 'op' },
          { id: 'x2',    label: '$project',  kind: 'stage' },
          { id: 'x3',    label: 'insert',    kind: 'value' }
        ]
      },
      {
        id: 's2', title: 'Change Stream — filter critical events', kind: 'fill',
        prompt: 'Only react when the incoming event crosses the critical threshold.',
        sub:    'Filter on fullDocument fields so low-priority changes never reach the handler.',
        why:    'Filtering inside the change stream keeps downstream functions, queues, and dashboards focused on events that actually require action.',
        snippet: [
          'db.events.watch([',
          '\n  { $match: { "fullDocument.priorityScore": { ', { blank: 'op' }, ': ', { blank: 'threshold' }, ' } } }',
          '\n])'
        ],
        choices: {
          op:        { options: ['$gte', '$gt', '$lte', '$eq'], answer: '$gte' },
          threshold: { options: ['90', '"90"', '9', 'true'], answer: '90' }
        }
      },
      {
        id: 's3', title: 'Atlas Stream Processing — route alerts', kind: 'reorder',
        prompt: 'Build a stream processor: read events, filter critical ones, shape alerts, then write them.',
        sub:    '$source → $match → $project → $merge keeps the stream useful and app-ready.',
        why:    'Atlas Stream Processing lets teams continuously transform and route operational events without building a separate stream-processing stack.',
        stages: [
          { id: 'src', code: '$source: { connectionName: "atlas", db: "app", coll: "events" }', sub: 'read the live event source', correct: 0 },
          { id: 'mat', code: '$match: { priorityScore: { $gte: 90 } }', sub: 'keep critical events only', correct: 1 },
          { id: 'prj', code: '$project: { _id: 0, eventId: 1, priorityScore: 1, alertType: 1, observedAt: "$$NOW" }', sub: 'shape alert payloads', correct: 2 },
          { id: 'mrg', code: '$merge: { into: { db: "app", coll: "alerts" } }', sub: 'write routed alerts', correct: 3 }
        ],
        initial: ['mrg', 'prj', 'src', 'mat']
      },
      {
        id: 's4', title: 'Stream output — alert collection', kind: 'fill',
        prompt: 'Write processed stream alerts into the alerts collection for apps and dashboards.',
        sub:    '$merge routes processed events back into MongoDB as operational alerts.',
        why:    'Writing stream output into MongoDB keeps the real-time alert state queryable by dashboards, APIs, and downstream automation.',
        snippet: [
          '{ ', { blank: 'stage' }, ': { into: { db: "app", coll: ', { blank: 'coll' }, ' }, whenMatched: ', { blank: 'mode' }, ' } }'
        ],
        choices: {
          stage: { options: ['$merge', '$out', '$insert', '$route'], answer: '$merge' },
          coll:  { options: ['"alerts"', 'alerts', '"events"', '"archive"'], answer: '"alerts"' },
          mode:  { options: ['"replace"', 'replace', '"drop"', '"ignore"'], answer: '"replace"' }
        }
      }
    ]
  }
];

/* ============================================================
 * Industry pack registry & helpers
 * ============================================================ */
window.DBLINGO_INDUSTRIES = {};

function registerDBLingoIndustry(pack) {
  window.DBLINGO_INDUSTRIES[pack.id] = pack;
  return pack;
}

function createIndustryWorlds(profile) {
  const worlds = JSON.parse(JSON.stringify(WORLDS));
  const nouns = profile.nouns || {};
  const aha = profile.aha || [];
  const levelOverrides = profile.levels || {};

  worlds.forEach((world, wi) => {
    world.levels.forEach((level, li) => {
      const idx = wi * 4 + li;
      const moment = aha[idx % Math.max(aha.length, 1)] || {
        title: 'AHA: ' + profile.name + ' runs on connected data',
        message: profile.promise
      };
      level.aha = moment;

      // Apply full level override if provided
      if (levelOverrides[level.id]) {
        const override = levelOverrides[level.id];
        Object.keys(override).forEach(function(key) {
          level[key] = override[key];
        });
      }
    });
  });

  const [docs, query, agg, idxWorld, atlas, streams] = worlds;
  const stream = Object.assign({
    eventCollection: nouns.itemCollection || nouns.transactionPlural || 'events',
    alertCollection: 'alerts',
    eventPlural: nouns.transactionPlural || nouns.itemPlural || 'events',
    criticalLabel: 'critical events',
    scoreField: 'priorityScore',
    threshold: 90,
    alertType: 'critical_event',
    sourceDb: 'app',
    handler: 'routeCriticalEvent',
    outcome: 'alert dashboards and downstream automation'
  }, profile.stream || {});

  // Only apply generic text substitutions for levels that were NOT overridden
  if (!levelOverrides['d1']) {
    docs.levels[0].title = 'Model a ' + (nouns.profile || 'profile') + ' document';
    docs.levels[0].prompt = 'Drag the right values into a ' + profile.name + ' ' + (nouns.profile || 'profile') + ' document.';
    docs.levels[0].why = profile.name + ' teams move fast when operational data fits the way the business thinks. MongoDB documents keep rich ' + (nouns.profile || 'profile') + ' context together without forcing every new attribute through a rigid migration.';
  }
  if (!levelOverrides['d2']) {
    // Name the exact collection: learners can't guess it from a noun like "catalog".
    const d2Col = (docs.levels[1].bank.find(function(b) { return b.answer === 'col'; }) || {}).label || 'products';
    docs.levels[1].prompt = 'Insert a new ' + (nouns.item || 'record') + ' into the `' + d2Col + '` collection. Drag the missing pieces.';
    docs.levels[1].why = 'MongoDB makes it natural to capture new ' + (nouns.itemPlural || 'records') + ' as JSON-shaped events, products, assets, or cases while preserving room for industry-specific fields.';
  }

  docs.name = (profile.shortName || profile.name) + ' Documents';
  docs.tagline = 'Model the domain';
  docs.blurb = profile.promise;

  query.name = (profile.shortName || profile.name) + ' Queries';
  query.tagline = 'Ask operational questions';
  query.blurb = 'Find and filter ' + profile.name + ' data in the shapes applications actually need.';
  if (!levelOverrides['q1']) {
    query.levels[0].prompt = 'Find every ' + (nouns.user || 'user') + ' whose segment is "priority".';
    query.levels[0].snippet = ['db.', { slot: 'field' }, '.find({ segment: ', { slot: 'val' }, ' })'];
    query.levels[0].bank = [
      { id: 'field', label: nouns.profileCollection || 'customers', kind: 'field', answer: 'field' },
      { id: 'val', label: '"priority"', kind: 'value', answer: 'val' },
      { id: 'x1', label: nouns.itemCollection || 'events', kind: 'field' },
      { id: 'x2', label: 'priority', kind: 'value' },
      { id: 'x3', label: 'tier', kind: 'field' }
    ];
    query.levels[0].why = 'MongoDB indexes make high-volume ' + profile.name + ' lookups fast while keeping each ' + (nouns.profile || 'profile') + ' flexible enough for changing business signals.';
  }
  if (!levelOverrides['q2']) {
    query.levels[1].prompt = 'Find ' + (nouns.transactionPlural || 'events') + ' over the important threshold. Drag the operator and value.';
    query.levels[1].why = 'Aggregation lets ' + profile.name + ' teams filter early, transform in place, and feed dashboards, apps, and AI workflows from the same operational data.';
  }

  agg.name = (profile.shortName || profile.name) + ' Pipelines';
  agg.tagline = 'Transform in place';
  agg.blurb = 'Turn ' + profile.name + ' events into ranked, joined, and shaped outcomes.';
  if (!levelOverrides['a1']) {
    agg.levels[0].prompt = profile.name + ': rank ' + (nouns.profilePlural || 'customers') + ' by 2024 value — re-order the stages.';
    agg.levels[0].why = 'The aggregation pipeline is MongoDB\'s in-database transformation engine: filter, group, rank, and reshape ' + profile.name + ' data without exporting it to a separate ETL tier.';
  }
  if (!levelOverrides['a3']) {
    agg.levels[2].prompt = 'Attach each ' + (nouns.transaction || 'event') + ' to its ' + (nouns.profile || 'profile') + ' record, then keep only the fields the app needs.';
    agg.levels[2].why = 'MongoDB supports embedding when data is accessed together and $lookup when independent entities need to meet at query time — a practical fit for ' + profile.name + '.';
  }

  idxWorld.name = (profile.shortName || profile.name) + ' Performance';
  idxWorld.tagline = 'Make reads fast';
  idxWorld.blurb = 'Index the ' + profile.name + ' access patterns that matter.';
  if (!levelOverrides['i1']) {
    idxWorld.levels[0].prompt = 'Classify the best index strategy for common ' + profile.name + ' query shapes.';
    idxWorld.levels[0].why = 'MongoDB performance tuning maps directly to how ' + profile.name + ' applications read data: equality lookups, compound filter+sort patterns, Atlas Search, and low-cardinality fields that should not be indexed alone.';
  }
  if (!levelOverrides['i2']) {
    idxWorld.levels[1].prompt = 'Put this ' + profile.name + ' compound index in ESR order: Equality, Sort, Range.';
  }

  atlas.name = (profile.shortName || profile.name) + ' Atlas AI';
  atlas.tagline = 'Search, vectors, triggers';
  atlas.blurb = 'Use Atlas Search and Vector Search to build smarter ' + profile.name + ' experiences.';
  if (!levelOverrides['v1']) {
    atlas.levels[0].prompt = 'Find the 5 nearest ' + (nouns.itemPlural || 'records') + ' to an embedding.';
    atlas.levels[0].why = 'Vector Search lets ' + profile.name + ' teams build semantic search and RAG over operational data already living in MongoDB Atlas.';
  }
  if (!levelOverrides['v2']) {
    atlas.levels[1].prompt = 'Use Atlas Search to find ' + (nouns.documentPlural || 'documents') + ' mentioning "' + (profile.searchPhrase || 'aggregation pipeline') + '".';
    atlas.levels[1].bank = atlas.levels[1].bank.map(function(b) { return b.id === 'query' ? Object.assign({}, b, { label: '"' + (profile.searchPhrase || 'aggregation pipeline') + '"' }) : b; });
    atlas.levels[1].why = 'Atlas Search gives ' + profile.name + ' applications relevance scoring, analyzers, fuzzy matching, autocomplete, and highlighting without bolting on a separate search cluster.';
  }
  if (!levelOverrides['v3']) {
    atlas.levels[2] = atlas.levels[2]; // no change needed
  }
  if (!levelOverrides['v4']) {
    atlas.levels[3].prompt = profile.name + ' RAG pipeline: scope by tenant or domain, retrieve semantically, then trim payload.';
    atlas.levels[3].why = 'MongoDB Atlas brings operational data, search, vector search, and app services together so ' + profile.name + ' teams can build AI features with fewer moving parts.';
  }

  streams.name = (profile.shortName || profile.name) + ' Streams';
  streams.tagline = 'React in real time';
  streams.blurb = 'Use Change Streams and Atlas Stream Processing to turn ' + stream.eventPlural + ' into live ' + stream.outcome + '.';
  if (!levelOverrides['s1']) {
    streams.levels[0].prompt = 'Watch for new ' + stream.eventPlural + ' as they are inserted.';
    streams.levels[0].sub = 'Change streams let ' + profile.name + ' apps react to writes without polling.';
    streams.levels[0].why = 'In ' + profile.name + ', teams need to react the moment important operational data lands. Change streams expose inserts, updates, replaces, and deletes as an ordered event stream.';
    streams.levels[0].snippet = [
      'db.', { slot: 'col' }, '.watch([',
      '\n  { ', { slot: 'stage' }, ': { operationType: ', { slot: 'evt' }, ' } }',
      '\n])'
    ];
    streams.levels[0].bank = [
      { id: 'col', label: stream.eventCollection, kind: 'field', answer: 'col' },
      { id: 'stage', label: '$match', kind: 'stage', answer: 'stage' },
      { id: 'evt', label: '"insert"', kind: 'value', answer: 'evt' },
      { id: 'x1', label: 'listen', kind: 'op' },
      { id: 'x2', label: '$project', kind: 'stage' },
      { id: 'x3', label: 'insert', kind: 'value' }
    ];
  }
  if (!levelOverrides['s2']) {
    streams.levels[1].prompt = 'Only react when incoming ' + stream.eventPlural + ' become ' + stream.criticalLabel + '.';
    streams.levels[1].snippet = [
      'db.' + stream.eventCollection + '.watch([',
      '\n  { $match: { "fullDocument.' + stream.scoreField + '": { ', { blank: 'op' }, ': ', { blank: 'threshold' }, ' } } }',
      '\n])'
    ];
    streams.levels[1].choices.threshold = { options: [String(stream.threshold), '"' + stream.threshold + '"', String(Math.max(1, Math.floor(stream.threshold / 10))), 'true'], answer: String(stream.threshold) };
    streams.levels[1].why = 'Filtering on `fullDocument.' + stream.scoreField + '` inside the change stream keeps ' + profile.name + ' handlers focused on ' + stream.criticalLabel + ' instead of processing every write.';
  }
  if (!levelOverrides['s3']) {
    streams.levels[2].prompt = 'Build a stream processor: read ' + stream.eventPlural + ', filter ' + stream.criticalLabel + ', shape alerts, then write them.';
    streams.levels[2].stages = [
      { id: 'src', code: '$source: { connectionName: "atlas", db: "' + stream.sourceDb + '", coll: "' + stream.eventCollection + '" }', sub: 'read the live ' + stream.eventCollection + ' source', correct: 0 },
      { id: 'mat', code: '$match: { ' + stream.scoreField + ': { $gte: ' + stream.threshold + ' } }', sub: 'keep ' + stream.criticalLabel + ' only', correct: 1 },
      { id: 'prj', code: '$project: { _id: 0, eventId: 1, ' + stream.scoreField + ': 1, alertType: "' + stream.alertType + '", observedAt: "$$NOW" }', sub: 'shape alert payloads', correct: 2 },
      { id: 'mrg', code: '$merge: { into: { db: "' + stream.sourceDb + '", coll: "' + stream.alertCollection + '" } }', sub: 'write routed alerts', correct: 3 }
    ];
    streams.levels[2].why = 'Atlas Stream Processing continuously transforms ' + profile.name + ' events into operational outputs without a separate stream-processing tier.';
  }
  if (!levelOverrides['s4']) {
    streams.levels[3].prompt = 'Write processed stream alerts into the ' + stream.alertCollection + ' collection for ' + stream.outcome + '.';
    streams.levels[3].snippet = [
      '{ ', { blank: 'stage' }, ': { into: { db: "' + stream.sourceDb + '", coll: ', { blank: 'coll' }, ' }, whenMatched: ', { blank: 'mode' }, ' } }'
    ];
    streams.levels[3].choices.coll = { options: ['"' + stream.alertCollection + '"', stream.alertCollection, '"' + stream.eventCollection + '"', '"archive"'], answer: '"' + stream.alertCollection + '"' };
    streams.levels[3].why = 'Routing processed events into `' + stream.alertCollection + '` keeps ' + profile.name + ' real-time state queryable by dashboards, APIs, and downstream automation.';
  }

  return worlds;
}

function createDBLingoIndustryPack(profile) {
  return {
    id: profile.id,
    name: profile.name,
    shortName: profile.shortName || profile.name,
    description: profile.description || profile.promise,
    promise: profile.promise,
    hints: Object.assign({}, HINTS, profile.hints || {}),
    worlds: createIndustryWorlds(profile)
  };
}

/* Register the general/default pack */
registerDBLingoIndustry({
  id: 'general',
  name: 'General MongoDB Foundations',
  shortName: 'General',
  description: 'A broad MongoDB learning path from documents to Atlas Search and Vector Search.',
  promise: 'MongoDB fits modern applications because documents, indexes, aggregation, search, and vectors work together in one developer data platform.',
  hints: HINTS,
  worlds: WORLDS
});

window.WORLDS = WORLDS;
window.HINTS  = HINTS;
window.LEVEL_HINTS = LEVEL_HINTS;
window.LEVEL_DOCS = LEVEL_DOCS;
window.WORLD_SKILL_BADGES = WORLD_SKILL_BADGES;