{
  "schema": 1,
  "subjects": [
    {
      "id": "javascript",
      "title": "JavaScript: beginner to production",
      "summary": "Build from values and control flow through data structures, asynchronous ownership, browser boundaries, testing and production incident repair.",
      "plans": ["free", "web", "plus", "pro"],
      "authored_unit_count": 20,
      "path": "/curriculum/javascript"
    },
    {
      "id": "typescript",
      "title": "TypeScript: contracts at scale",
      "summary": "Move from type fundamentals to safe domain models, generics, public APIs, asynchronous ownership, migrations and production boundary design.",
      "plans": ["web", "plus", "pro"],
      "authored_unit_count": 20,
      "path": "/curriculum/typescript"
    },
    {
      "id": "python",
      "title": "Python: beginner to production",
      "summary": "Learn the language from first values through records, iteration, files, concurrency, tested services and failure-safe production workflows.",
      "plans": ["web", "plus", "pro"],
      "authored_unit_count": 20,
      "path": "/curriculum/python"
    },
    {
      "id": "sql",
      "title": "SQL: data reasoning to production",
      "summary": "Progress from relational foundations through joins, windows, transactions, schema change, performance, concurrency and trustworthy reporting.",
      "plans": ["web", "plus", "pro"],
      "authored_unit_count": 20,
      "path": "/curriculum/sql"
    },
    {
      "id": "frontend",
      "title": "Frontend engineering",
      "summary": "Build semantic, accessible and resilient interfaces through browser behavior, layout systems, forms, performance, state and recovery.",
      "plans": ["web", "plus", "pro"],
      "authored_unit_count": 20,
      "path": "/curriculum/frontend"
    },
    {
      "id": "react",
      "title": "React application engineering",
      "summary": "Move from rendering and state identity through reducers, effects, accessibility, server rendering, performance and complete feature transfer.",
      "plans": ["web", "plus", "pro"],
      "authored_unit_count": 20,
      "path": "/curriculum/react"
    },
    {
      "id": "angular",
      "title": "Angular application engineering",
      "summary": "Master components, templates, dependency scopes, forms, reactive streams, routing, testing, performance and production feature ownership.",
      "plans": ["web", "plus", "pro"],
      "authored_unit_count": 20,
      "path": "/curriculum/angular"
    },
    {
      "id": "php",
      "title": "PHP: requests to reliable services",
      "summary": "Learn PHP values and collections, then own HTTP, persistence, security, concurrency, diagnostics and a complete service publication.",
      "plans": ["web", "plus", "pro"],
      "authored_unit_count": 20,
      "path": "/curriculum/php"
    },
    {
      "id": "backend",
      "title": "Backend reliability engineering",
      "summary": "Design service boundaries, validation, persistence, concurrency, queues, deadlines, observability and recovery across complete incidents.",
      "plans": ["web", "plus", "pro"],
      "authored_unit_count": 20,
      "path": "/curriculum/backend"
    },
    {
      "id": "middleware",
      "title": "Middleware and integration engineering",
      "summary": "Carry explicit contracts through delivery, replay, ordering, schemas, deadlines, poison messages, sagas, gateways and restart-safe change.",
      "plans": ["web", "plus", "pro"],
      "authored_unit_count": 20,
      "path": "/curriculum/middleware"
    },
    {
      "id": "architecture",
      "title": "Software architecture under change",
      "summary": "Reason from ownership and dependency direction through consistency, capacity, migration, operability and changed-constraint decisions.",
      "plans": ["web", "plus", "pro"],
      "authored_unit_count": 20,
      "path": "/curriculum/architecture"
    },
    {
      "id": "llm-rag",
      "title": "LLM and RAG engineering",
      "summary": "Build the conceptual and executable foundations of language models, training, retrieval, evaluation, access control and grounded systems.",
      "plans": ["web", "plus", "pro"],
      "authored_unit_count": 20,
      "path": "/curriculum/llm-rag"
    },
    {
      "id": "agentic",
      "title": "Agentic programming",
      "summary": "Program effectively with AI through task design, context, tools, permissions, verification, bounded execution, traces and completion review.",
      "plans": ["web", "plus", "pro"],
      "authored_unit_count": 20,
      "path": "/curriculum/agentic"
    },
    {
      "id": "node",
      "title": "Node.js service engineering",
      "summary": "Progress from modules and files through streams, HTTP, asynchronous ownership, workers, persistence, security and service incidents.",
      "plans": ["plus", "pro"],
      "authored_unit_count": 20,
      "path": "/curriculum/node"
    },
    {
      "id": "go",
      "title": "Go: systems and services",
      "summary": "Learn Go from values and errors through interfaces, streams, concurrency, networking, persistence and race-checked service delivery.",
      "plans": ["plus", "pro"],
      "authored_unit_count": 20,
      "path": "/curriculum/go"
    },
    {
      "id": "rust",
      "title": "Rust: ownership to reliable systems",
      "summary": "Develop ownership fluency, typed failure, collections, I/O, concurrency, protocols and safe library boundaries through complete transfers.",
      "plans": ["plus", "pro"],
      "authored_unit_count": 20,
      "path": "/curriculum/rust"
    },
    {
      "id": "c",
      "title": "C: memory, representation and systems",
      "summary": "Progress from representation and pointers through allocation, text, binary protocols, files, owned structures and instrumented parsers.",
      "plans": ["plus", "pro"],
      "authored_unit_count": 20,
      "path": "/curriculum/c"
    },
    {
      "id": "cpp",
      "title": "C++: value semantics to concurrent systems",
      "summary": "Master lifetimes, RAII, containers, generic contracts, files, ranges, concurrency and a production-quality native library capstone.",
      "plans": ["plus", "pro"],
      "authored_unit_count": 20,
      "path": "/curriculum/cpp"
    },
    {
      "id": "csharp",
      "title": "C#: applications and asynchronous systems",
      "summary": "Move from nullable values and LINQ through serialization, async streams, resources, reflection, plugins and single-flight application state.",
      "plans": ["plus", "pro"],
      "authored_unit_count": 20,
      "path": "/curriculum/csharp"
    },
    {
      "id": "aspnet",
      "title": "ASP.NET Core service engineering",
      "summary": "Own the request pipeline, binding, authorization, dependency lifetimes, data concurrency, diagnostics, operations and real-host transfer.",
      "plans": ["plus", "pro"],
      "authored_unit_count": 20,
      "path": "/curriculum/aspnet"
    },
    {
      "id": "application-security",
      "title": "Application Security",
      "summary": "Repair access, rendering, query and business-rule boundaries in a fictional application, with evidence that attacks fail and legitimate work still succeeds.",
      "plans": ["web", "plus", "pro"],
      "authored_unit_count": 4,
      "path": "/curriculum/application-security"
    },
    {
      "id": "security-research",
      "title": "Security Research",
      "summary": "Develop bounded reproductions, explain the failed trust boundary, repair it, and write regressions that distinguish the original from the repaired target.",
      "plans": ["plus", "pro"],
      "authored_unit_count": 2,
      "path": "/curriculum/security-research"
    }
  ],
  "lessons": [
    {
      "id": "javascript.lesson.syllabus-01-run-something-and-read-the-output",
      "subject": "javascript",
      "title": "Read an input, return a result, and test one decision",
      "objective": "Run a small function, distinguish its returned value from printed output, and choose between two numeric inputs.",
      "unit_id": "javascript.course.foundations.01-run-something-and-read-the-output",
      "path": "/curriculum/javascript?unit=javascript.course.foundations.01-run-something-and-read-the-output",
      "public_teaching": true,
      "plans": ["free", "web", "plus", "pro"]
    },
    {
      "id": "javascript.lesson.syllabus-02-numbers-and-the-one-number-type",
      "subject": "javascript",
      "title": "Visit each value, then count only a match",
      "objective": "Accumulate values in one loop, then transfer that loop to a counter with one equality condition.",
      "unit_id": "javascript.course.foundations.02-numbers-and-the-one-number-type",
      "path": "/curriculum/javascript?unit=javascript.course.foundations.02-numbers-and-the-one-number-type",
      "public_teaching": true,
      "plans": ["free", "web", "plus", "pro"]
    },
    {
      "id": "javascript.lesson.syllabus-03-the-coercion-table-by-experiment",
      "subject": "javascript",
      "title": "Validate complete text, then change the accepted range",
      "objective": "Build a complete decimal parser and transfer its validation pipeline to a bounded retry setting.",
      "unit_id": "javascript.course.foundations.03-the-coercion-table-by-experiment",
      "path": "/curriculum/javascript?unit=javascript.course.foundations.03-the-coercion-table-by-experiment",
      "public_teaching": true,
      "plans": ["free", "web", "plus", "pro"]
    },
    {
      "id": "javascript.lesson.syllabus-04-functions-as-values",
      "subject": "javascript",
      "title": "Classify records once and preserve encounter order",
      "objective": "Keep the first record for each key, then classify a sequence into stable accepted and rejected groups.",
      "unit_id": "javascript.course.foundations.04-functions-as-values",
      "path": "/curriculum/javascript?unit=javascript.course.foundations.04-functions-as-values",
      "public_teaching": true,
      "plans": ["free", "web", "plus", "pro"]
    },
    {
      "id": "javascript.lesson.syllabus-05-truncate-unicode-text",
      "subject": "javascript",
      "title": "Traverse a tree and make recursive summaries",
      "objective": "Combine each node with its child summaries, reading observable properties once and preserving caller data.",
      "unit_id": "javascript.course.foundations.05-truncate-unicode-text",
      "path": "/curriculum/javascript?unit=javascript.course.foundations.05-truncate-unicode-text",
      "public_teaching": true,
      "plans": ["free", "web", "plus", "pro"]
    },
    {
      "id": "javascript.lesson.syllabus-06-format-absolute-units-before-the-sign",
      "subject": "javascript",
      "title": "Separate own properties from inherited authority",
      "objective": "Traverse literal own-property paths and store arbitrary names without allowing prototype behavior to change the result.",
      "unit_id": "javascript.course.foundations.06-format-absolute-units-before-the-sign",
      "path": "/curriculum/javascript?unit=javascript.course.foundations.06-format-absolute-units-before-the-sign",
      "public_teaching": true,
      "plans": ["free", "web", "plus", "pro"]
    },
    {
      "id": "javascript.lesson.syllabus-07-observe-actual-live-module-exports-after-updates",
      "subject": "javascript",
      "title": "Validate saved state before publishing a restored view",
      "objective": "Validate a saved task envelope and an exact configuration schema, preserving deliberate zero and false values and each boundary’s declared failure policy.",
      "unit_id": "javascript.course.foundations.07-observe-actual-live-module-exports-after-updates",
      "path": "/curriculum/javascript?unit=javascript.course.foundations.07-observe-actual-live-module-exports-after-updates",
      "public_teaching": true,
      "plans": ["free", "web", "plus", "pro"]
    },
    {
      "id": "javascript.lesson.syllabus-08-index-records-with-arbitrary-string-keys",
      "subject": "javascript",
      "title": "Parse escaped fields with explicit state",
      "objective": "Distinguish a delimiter from escaped data and reject an unfinished escape without losing empty fields.",
      "unit_id": "javascript.course.foundations.08-index-records-with-arbitrary-string-keys",
      "path": "/curriculum/javascript?unit=javascript.course.foundations.08-index-records-with-arbitrary-string-keys",
      "public_teaching": true,
      "plans": ["free", "web", "plus", "pro"]
    },
    {
      "id": "javascript.lesson.syllabus-09-all-allsettled-race-any",
      "subject": "javascript",
      "title": "Pull only the values a consumer requests",
      "objective": "Construct lazy iterable transformations and stop without over-consuming their source.",
      "unit_id": "javascript.course.foundations.09-all-allsettled-race-any",
      "path": "/curriculum/javascript?unit=javascript.course.foundations.09-all-allsettled-race-any",
      "public_teaching": true,
      "plans": ["free", "web", "plus", "pro"]
    },
    {
      "id": "javascript.lesson.syllabus-10-choose-the-smaller-child",
      "subject": "javascript",
      "title": "Maintain a binary heap after each change",
      "objective": "Restore the parent-child ordering invariant locally rather than sorting the whole queue after every operation.",
      "unit_id": "javascript.course.foundations.10-choose-the-smaller-child",
      "path": "/curriculum/javascript?unit=javascript.course.foundations.10-choose-the-smaller-child",
      "public_teaching": true,
      "plans": ["free", "web", "plus", "pro"]
    },
    {
      "id": "javascript.lesson.syllabus-11-find-the-prefix-node-first",
      "subject": "javascript",
      "title": "Index prefixes without confusing traversal and ordering",
      "objective": "Insert and traverse trie edges by Unicode code point, then produce the contract’s code-unit ordering.",
      "unit_id": "javascript.course.foundations.11-find-the-prefix-node-first",
      "path": "/curriculum/javascript?unit=javascript.course.foundations.11-find-the-prefix-node-first",
      "public_teaching": true,
      "plans": ["free", "web", "plus", "pro"]
    },
    {
      "id": "javascript.lesson.syllabus-12-retain-element-identity",
      "subject": "javascript",
      "title": "Keep local sequence boundaries and route costs explicit",
      "objective": "Group consecutive equal readings, then choose minimum-cost routes using tentative distances and relaxation.",
      "unit_id": "javascript.course.foundations.12-retain-element-identity",
      "path": "/curriculum/javascript?unit=javascript.course.foundations.12-retain-element-identity",
      "public_teaching": true,
      "plans": ["free", "web", "plus", "pro"]
    },
    {
      "id": "javascript.lesson.syllabus-13-compare-three-edit-choices",
      "subject": "javascript",
      "title": "Discover a route and reconstruct its evidence",
      "objective": "Separate neighbor admission, predecessor ownership and path reconstruction before combining them in unweighted search.",
      "unit_id": "javascript.course.foundations.13-compare-three-edit-choices",
      "path": "/curriculum/javascript?unit=javascript.course.foundations.13-compare-three-edit-choices",
      "public_teaching": true,
      "plans": ["free", "web", "plus", "pro"]
    },
    {
      "id": "javascript.lesson.syllabus-14-rounding-cannot-restore-lost-input",
      "subject": "javascript",
      "title": "Decode complete binary frames without losing text",
      "objective": "Interpret declared byte lengths, reject incomplete or malformed frames, and preserve valid UTF-8 content exactly.",
      "unit_id": "javascript.course.foundations.14-rounding-cannot-restore-lost-input",
      "path": "/curriculum/javascript?unit=javascript.course.foundations.14-rounding-cannot-restore-lost-input",
      "public_teaching": true,
      "plans": ["free", "web", "plus", "pro"]
    },
    {
      "id": "javascript.lesson.syllabus-15-claim-an-input-position-before-awaiting",
      "subject": "javascript",
      "title": "Bound in-flight work and inject retry waiting",
      "objective": "Claim jobs before awaiting, cap active operations, and retry only within an explicit attempt and cancellation policy.",
      "unit_id": "javascript.course.foundations.15-claim-an-input-position-before-awaiting",
      "path": "/curriculum/javascript?unit=javascript.course.foundations.15-claim-an-input-position-before-awaiting",
      "public_teaching": true,
      "plans": ["free", "web", "plus", "pro"]
    },
    {
      "id": "javascript.lesson.syllabus-16-pending-work-has-a-lifetime",
      "subject": "javascript",
      "title": "Adapt callbacks and retain asynchronous publication ownership",
      "objective": "Bridge callback completion into promises, then prevent an obsolete search from publishing after a newer request.",
      "unit_id": "javascript.course.foundations.16-pending-work-has-a-lifetime",
      "path": "/curriculum/javascript?unit=javascript.course.foundations.16-pending-work-has-a-lifetime",
      "public_teaching": true,
      "plans": ["free", "web", "plus", "pro"]
    },
    {
      "id": "javascript.lesson.syllabus-17-keep-loading-and-ready-transitions-visible",
      "subject": "javascript",
      "title": "Publish validated project state under reentrant requests",
      "objective": "Keep loading, ready and error transitions observable while preserving ownership through abort callbacks and detached snapshots.",
      "unit_id": "javascript.course.foundations.17-keep-loading-and-ready-transitions-visible",
      "path": "/curriculum/javascript?unit=javascript.course.foundations.17-keep-loading-and-ready-transitions-visible",
      "public_teaching": true,
      "plans": ["free", "web", "plus", "pro"]
    },
    {
      "id": "javascript.lesson.syllabus-18-return-snapshots-with-owned-containers",
      "subject": "javascript",
      "title": "Own queue links, snapshots and transferred buffers",
      "objective": "Maintain queue endpoint invariants and distinguish copying a container from transferring its backing resource.",
      "unit_id": "javascript.course.foundations.18-return-snapshots-with-owned-containers",
      "path": "/curriculum/javascript?unit=javascript.course.foundations.18-return-snapshots-with-owned-containers",
      "public_teaching": true,
      "plans": ["free", "web", "plus", "pro"]
    },
    {
      "id": "javascript.lesson.syllabus-19-find-zero-width-matches-without-leaking-lastindex",
      "subject": "javascript",
      "title": "Choose failure semantics for concurrent jobs",
      "objective": "Separate fail-fast aggregation from complete per-job evidence while preserving input order and bounded starts.",
      "unit_id": "javascript.course.foundations.19-find-zero-width-matches-without-leaking-lastindex",
      "path": "/curriculum/javascript?unit=javascript.course.foundations.19-find-zero-width-matches-without-leaking-lastindex",
      "public_teaching": true,
      "plans": ["free", "web", "plus", "pro"]
    },
    {
      "id": "javascript.lesson.syllabus-20-redistribute-dangling-mass",
      "subject": "javascript",
      "title": "Keep subscription and edit ownership current through reentry",
      "objective": "Honor current subscription eligibility during event dispatch, then protect asynchronous draft publication with an edit revision.",
      "unit_id": "javascript.course.foundations.20-redistribute-dangling-mass",
      "path": "/curriculum/javascript?unit=javascript.course.foundations.20-redistribute-dangling-mass",
      "public_teaching": true,
      "plans": ["free", "web", "plus", "pro"]
    },
    {
      "id": "typescript.lesson.syllabus-01-what-the-compiler-already-knows",
      "subject": "typescript",
      "title": "Separate static types from runtime values",
      "objective": "Use compiler feedback to describe accepted values, then check numeric domain rules before arithmetic.",
      "unit_id": "typescript.course.foundations.01-what-the-compiler-already-knows",
      "path": "/curriculum/typescript?unit=typescript.course.foundations.01-what-the-compiler-already-knows",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "typescript.lesson.syllabus-02-choose-nullish-coalescing",
      "subject": "typescript",
      "title": "Preserve optional fields and deliberate empty values",
      "objective": "Copy an update without changing the source, and distinguish removal, absence, and a present value.",
      "unit_id": "typescript.course.foundations.02-choose-nullish-coalescing",
      "path": "/curriculum/typescript?unit=typescript.course.foundations.02-choose-nullish-coalescing",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "typescript.lesson.syllabus-03-preserve-unrelated-fields",
      "subject": "typescript",
      "title": "Keep positional types and owned field types precise",
      "objective": "Build readonly typed pairs, then project known owned properties without widening their value types.",
      "unit_id": "typescript.course.foundations.03-preserve-unrelated-fields",
      "path": "/curriculum/typescript?unit=typescript.course.foundations.03-preserve-unrelated-fields",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "typescript.lesson.syllabus-04-preserve-element-identity",
      "subject": "typescript",
      "title": "Keep collection absence separate from stored values",
      "objective": "Operate bounded storage without conflating missing entries with valid falsy payloads or exposing mutable snapshot containers.",
      "unit_id": "typescript.course.foundations.04-preserve-element-identity",
      "path": "/curriculum/typescript?unit=typescript.course.foundations.04-preserve-element-identity",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "typescript.lesson.syllabus-05-keep-event-names-and-callback-values-paired",
      "subject": "typescript",
      "title": "Narrow tagged values and transition owned state",
      "objective": "Narrow each payment alternative by its literal tag, then use event alternatives to implement validated add, undo, and reset transitions.",
      "unit_id": "typescript.course.foundations.05-keep-event-names-and-callback-values-paired",
      "path": "/curriculum/typescript?unit=typescript.course.foundations.05-keep-event-names-and-callback-values-paired",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "typescript.lesson.syllabus-06-accept-unknown-at-an-external-boundary",
      "subject": "typescript",
      "title": "Earn narrowing at the runtime boundary",
      "objective": "Validate identifier and record representations before granting a narrower static type.",
      "unit_id": "typescript.course.foundations.06-accept-unknown-at-an-external-boundary",
      "path": "/curriculum/typescript?unit=typescript.course.foundations.06-accept-unknown-at-an-external-boundary",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "typescript.lesson.syllabus-07-keep-assertions-localized",
      "subject": "typescript",
      "title": "Validate configuration and preserve unknown failures",
      "objective": "Admit configuration by its actual schema and narrow caught values without assuming that every throw is an Error.",
      "unit_id": "typescript.course.foundations.07-keep-assertions-localized",
      "path": "/curriculum/typescript?unit=typescript.course.foundations.07-keep-assertions-localized",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "typescript.lesson.syllabus-08-map-only-successful-values",
      "subject": "typescript",
      "title": "Preserve success shapes and checked keys",
      "objective": "Propagate async result alternatives and use constrained property keys to retain a precise returned object type.",
      "unit_id": "typescript.course.foundations.08-map-only-successful-values",
      "path": "/curriculum/typescript?unit=typescript.course.foundations.08-map-only-successful-values",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "typescript.lesson.syllabus-09-record-and-index-signatures",
      "subject": "typescript",
      "title": "Keep type transformations aligned with runtime keys",
      "objective": "Express mapped-property modifiers and implement prefixed string-key projection under the same declared boundary.",
      "unit_id": "typescript.course.foundations.09-record-and-index-signatures",
      "path": "/curriculum/typescript?unit=typescript.course.foundations.09-record-and-index-signatures",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "typescript.lesson.syllabus-10-keep-source-data-unchanged",
      "subject": "typescript",
      "title": "Read recursive shapes without acquiring mutation rights",
      "objective": "Preserve literal relationships and recursively describe readonly trees while counting depth and size.",
      "unit_id": "typescript.course.foundations.10-keep-source-data-unchanged",
      "path": "/curriculum/typescript?unit=typescript.course.foundations.10-keep-source-data-unchanged",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "typescript.lesson.syllabus-11-infer-the-promised-inner-type",
      "subject": "typescript",
      "title": "Expose precise function call contracts",
      "objective": "Preserve typed pipeline relationships and implement two overloads with distinct return types and runtime dispatch.",
      "unit_id": "typescript.course.foundations.11-infer-the-promised-inner-type",
      "path": "/curriculum/typescript?unit=typescript.course.foundations.11-infer-the-promised-inner-type",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "typescript.lesson.syllabus-12-create-an-owned-nonempty-tuple-after-validation",
      "subject": "typescript",
      "title": "Model function shapes and resolved outcomes",
      "objective": "Infer function relationships, recursively unwrap promise-like values, and preserve rejection values without coercion.",
      "unit_id": "typescript.course.foundations.12-create-an-owned-nonempty-tuple-after-validation",
      "path": "/curriculum/typescript?unit=typescript.course.foundations.12-create-an-owned-nonempty-tuple-after-validation",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "typescript.lesson.syllabus-13-reject-a-nonfunction-pattern",
      "subject": "typescript",
      "title": "Keep callable variance and route names explicit",
      "objective": "Check unsafe function substitutions, then align a literal route-name type with the corresponding runtime segment parser.",
      "unit_id": "typescript.course.foundations.13-reject-a-nonfunction-pattern",
      "path": "/curriculum/typescript?unit=typescript.course.foundations.13-reject-a-nonfunction-pattern",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "typescript.lesson.syllabus-14-test-the-unsafe-substitution",
      "subject": "typescript",
      "title": "Preserve transition and event identity",
      "objective": "Implement typed transitions and connect each event name to its argument tuple and independent registration lifetime.",
      "unit_id": "typescript.course.foundations.14-test-the-unsafe-substitution",
      "path": "/curriculum/typescript?unit=typescript.course.foundations.14-test-the-unsafe-substitution",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "typescript.lesson.syllabus-15-keep-heterogeneous-async-outcomes-in-their-original-po",
      "subject": "typescript",
      "title": "Bound async work and fence obsolete publication",
      "objective": "Keep batch execution bounded and let only the current search publish its eventual success or failure.",
      "unit_id": "typescript.course.foundations.15-keep-heterogeneous-async-outcomes-in-their-original-po",
      "path": "/curriculum/typescript?unit=typescript.course.foundations.15-keep-heterogeneous-async-outcomes-in-their-original-po",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "typescript.lesson.syllabus-16-count-visits-deterministically",
      "subject": "typescript",
      "title": "Separate scheduling order from tree combination",
      "objective": "Use priority ordering deliberately and reuse one typed binary-tree traversal with different combining functions.",
      "unit_id": "typescript.course.foundations.16-count-visits-deterministically",
      "path": "/curriculum/typescript?unit=typescript.course.foundations.16-count-visits-deterministically",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "typescript.lesson.syllabus-17-merge-with-two-cursors",
      "subject": "typescript",
      "title": "Preserve boundary and tie policies",
      "objective": "Locate sorted boundaries and perform stable merge sort without changing original equal-item order.",
      "unit_id": "typescript.course.foundations.17-merge-with-two-cursors",
      "path": "/curriculum/typescript?unit=typescript.course.foundations.17-merge-with-two-cursors",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "typescript.lesson.syllabus-18-validate-quantity-precision",
      "subject": "typescript",
      "title": "Keep numeric units and identity domains distinct",
      "objective": "Validate exact money and branded identifiers at their admission boundaries instead of trusting interchangeable runtime representations.",
      "unit_id": "typescript.course.foundations.18-validate-quantity-precision",
      "path": "/curriculum/typescript?unit=typescript.course.foundations.18-validate-quantity-precision",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "typescript.lesson.syllabus-19-key-remapping",
      "subject": "typescript",
      "title": "Project types and reject stale entity writes",
      "objective": "Keep mapped shapes precise, return detached entity records, and compare expected revision before applying a patch.",
      "unit_id": "typescript.course.foundations.19-key-remapping",
      "path": "/curriculum/typescript?unit=typescript.course.foundations.19-key-remapping",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "typescript.lesson.syllabus-20-test-independent-entity-state",
      "subject": "typescript",
      "title": "Make migration and command replay intentional",
      "objective": "Preserve populated migrated fields and reconcile command identity with revision-checked ledger effects.",
      "unit_id": "typescript.course.foundations.20-test-independent-entity-state",
      "path": "/curriculum/typescript?unit=typescript.course.foundations.20-test-independent-entity-state",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "python.lesson.syllabus-01-run-something-and-read-the-output",
      "subject": "python",
      "title": "Run a program, name a value, and return arithmetic results",
      "objective": "Name and print a string, then distinguish displayed output from the values returned by the separate arithmetic functions.",
      "unit_id": "python.course.foundations.01-run-something-and-read-the-output",
      "path": "/curriculum/python?unit=python.course.foundations.01-run-something-and-read-the-output",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "python.lesson.syllabus-02-comparison-and-truth",
      "subject": "python",
      "title": "Two names, one object",
      "objective": "Distinguish equal values from shared list identity and observe how mutation differs from rebinding a name.",
      "unit_id": "python.course.foundations.02-comparison-and-truth",
      "path": "/curriculum/python?unit=python.course.foundations.02-comparison-and-truth",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "python.lesson.syllabus-03-slicing",
      "subject": "python",
      "title": "Fix the expiry sweep",
      "objective": "Remove every expired session while preserving the caller’s list identity, survivor order and inclusive expiry boundary.",
      "unit_id": "python.course.foundations.03-slicing",
      "path": "/curriculum/python?unit=python.course.foundations.03-slicing",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "python.lesson.syllabus-04-the-string-methods-worth-knowing-by-heart",
      "subject": "python",
      "title": "Deciding, and the block that follows",
      "objective": "Return the correct threshold branch and count matching records through a complete loop without an early return.",
      "unit_id": "python.course.foundations.04-the-string-methods-worth-knowing-by-heart",
      "path": "/curriculum/python?unit=python.course.foundations.04-the-string-methods-worth-knowing-by-heart",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "python.lesson.syllabus-05-slices-are-copies",
      "subject": "python",
      "title": "Records, and things built from other things",
      "objective": "Construct independent mutable defaults and derive a changed frozen record without modifying its original.",
      "unit_id": "python.course.foundations.05-slices-are-copies",
      "path": "/curriculum/python?unit=python.course.foundations.05-slices-are-copies",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "python.lesson.syllabus-06-dictionary-and-set-comprehensions",
      "subject": "python",
      "title": "Translate it out of JavaScript",
      "objective": "Translate filtering and sorting into Python while preserving deliberately empty values and returning new collections.",
      "unit_id": "python.course.foundations.06-dictionary-and-set-comprehensions",
      "path": "/curriculum/python?unit=python.course.foundations.06-dictionary-and-set-comprehensions",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "python.lesson.syllabus-07-reading-a-file",
      "subject": "python",
      "title": "Reading and writing, without losing anything",
      "objective": "Read and write the declared text format using owned file contexts while preserving interior blank lines.",
      "unit_id": "python.course.foundations.07-reading-a-file",
      "path": "/curriculum/python?unit=python.course.foundations.07-reading-a-file",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "python.lesson.syllabus-08-any-number-of-arguments",
      "subject": "python",
      "title": "The base case, and the call you have not written yet",
      "objective": "Choose an empty base case and combine one smaller recursive result without indexing outside the input.",
      "unit_id": "python.course.foundations.08-any-number-of-arguments",
      "path": "/curriculum/python?unit=python.course.foundations.08-any-number-of-arguments",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "python.lesson.syllabus-09-translation-lab-from-javascript",
      "subject": "python",
      "title": "Validate configuration without flattening values",
      "objective": "Validate configuration types and values before use, preserving explicit zero and false instead of applying truthy defaults.",
      "unit_id": "python.course.foundations.09-translation-lab-from-javascript",
      "path": "/curriculum/python?unit=python.course.foundations.09-translation-lab-from-javascript",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "python.lesson.syllabus-10-duck-typing",
      "subject": "python",
      "title": "Dates, consecutive runs and a command line",
      "objective": "Use deterministic calendar arithmetic, consecutive-run grouping and explicit command-line parsing under their separate toolkit contracts.",
      "unit_id": "python.course.foundations.10-duck-typing",
      "path": "/curriculum/python?unit=python.course.foundations.10-duck-typing",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "python.lesson.syllabus-11-counting-what-actually-runs",
      "subject": "python",
      "title": "The visited set is the algorithm",
      "objective": "Use a FIFO frontier and discovery set to visit each reachable graph node once, even in a cycle.",
      "unit_id": "python.course.foundations.11-counting-what-actually-runs",
      "path": "/curriculum/python?unit=python.course.foundations.11-counting-what-actually-runs",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "python.lesson.syllabus-12-two-pointers-from-both-ends",
      "subject": "python",
      "title": "Validate an entire dynamic call before invoking it",
      "objective": "Validate a complete positional and keyword call before invoking its callback, preserving binding failures and return identity.",
      "unit_id": "python.course.foundations.12-two-pointers-from-both-ends",
      "path": "/curriculum/python?unit=python.course.foundations.12-two-pointers-from-both-ends",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "python.lesson.syllabus-13-spend-one-deadline-across-attempts-without-resetting-i",
      "subject": "python",
      "title": "Validate a complete CSV row schema without splitting quoted cells",
      "objective": "Parse quoted CSV through its actual row grammar and reject an invalid complete schema before returning accepted records.",
      "unit_id": "python.course.foundations.13-spend-one-deadline-across-attempts-without-resetting-i",
      "path": "/curriculum/python?unit=python.course.foundations.13-spend-one-deadline-across-attempts-without-resetting-i",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "python.lesson.syllabus-14-writing-a-generator",
      "subject": "python",
      "title": "Replay a command batch with exact duplicate identity",
      "objective": "Apply each new command identity once and reject conflicting replays without publishing any part of an invalid batch.",
      "unit_id": "python.course.foundations.14-writing-a-generator",
      "path": "/curriculum/python?unit=python.course.foundations.14-writing-a-generator",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "python.lesson.syllabus-15-parsing-something-that-is-not-json",
      "subject": "python",
      "title": "Count it, do not estimate it",
      "objective": "Instrument actual comparisons and pair visits so an algorithm’s reported work matches its execution.",
      "unit_id": "python.course.foundations.15-parsing-something-that-is-not-json",
      "path": "/curriculum/python?unit=python.course.foundations.15-parsing-something-that-is-not-json",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "python.lesson.syllabus-16-a-node-with-a-next",
      "subject": "python",
      "title": "A graph is a dictionary",
      "objective": "Represent directed adjacency explicitly, retaining target-only vertices and a deterministic neighbor order.",
      "unit_id": "python.course.foundations.16-a-node-with-a-next",
      "path": "/curriculum/python?unit=python.course.foundations.16-a-node-with-a-next",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "python.lesson.syllabus-17-depth-first",
      "subject": "python",
      "title": "Numbers that are nearly right",
      "objective": "Apply the stated numeric tolerance boundary and normalize weights without dividing an all-zero vector.",
      "unit_id": "python.course.foundations.17-depth-first",
      "path": "/curriculum/python?unit=python.course.foundations.17-depth-first",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "python.lesson.syllabus-18-counting-islands",
      "subject": "python",
      "title": "Build an all-or-nothing import report",
      "objective": "Stage an entire one-shot CSV import, report physical source locations and publish once only after every row validates.",
      "unit_id": "python.course.foundations.18-counting-islands",
      "path": "/curriculum/python?unit=python.course.foundations.18-counting-islands",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "python.lesson.syllabus-19-grid-paths",
      "subject": "python",
      "title": "Sort ordered records without losing equal-item order",
      "objective": "Implement ordered merges and partitioning without changing caller data, while preserving equal-key order where required.",
      "unit_id": "python.course.foundations.19-grid-paths",
      "path": "/curriculum/python?unit=python.course.foundations.19-grid-paths",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "python.lesson.syllabus-20-power-iteration",
      "subject": "python",
      "title": "Preserve rank mass through one graph distribution round",
      "objective": "Distribute one previous rank vector into a fresh vector, sharing dangling mass without losing total rank.",
      "unit_id": "python.course.foundations.20-power-iteration",
      "path": "/curriculum/python?unit=python.course.foundations.20-power-iteration",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "sql.lesson.syllabus-01-selecting-and-filtering",
      "subject": "sql",
      "title": "A cursor excludes the last seen identity",
      "objective": "Exclude the last seen identity and return the next bounded page in a declared deterministic order.",
      "unit_id": "sql.course.foundations.01-selecting-and-filtering",
      "path": "/curriculum/sql?unit=sql.course.foundations.01-selecting-and-filtering",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "sql.lesson.syllabus-02-positive-amounts-original-amount",
      "subject": "sql",
      "title": "Bind a lookup and select a nonoverlapping time period",
      "objective": "Keep a searched value out of SQL syntax by binding it through a fixed query rather than interpolating its spelling.",
      "unit_id": "sql.course.foundations.02-positive-amounts-original-amount",
      "path": "/curriculum/sql?unit=sql.course.foundations.02-positive-amounts-original-amount",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "sql.lesson.syllabus-03-amounts-from-10-to-30-net-amount",
      "subject": "sql",
      "title": "Search a literal fragment containing LIKE metacharacters",
      "objective": "Escape LIKE metacharacters so a searched fragment is literal data while retaining the intended surrounding wildcard search.",
      "unit_id": "sql.course.foundations.03-amounts-from-10-to-30-net-amount",
      "path": "/curriculum/sql?unit=sql.course.foundations.03-amounts-from-10-to-30-net-amount",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "sql.lesson.syllabus-04-discounted-orders-zero-defaulted-amount",
      "subject": "sql",
      "title": "Filter before projecting a stable result",
      "objective": "Filter strictly positive scores before projecting IDs, excluding unknown scores and ordering the accepted rows.",
      "unit_id": "sql.course.foundations.04-discounted-orders-zero-defaulted-amount",
      "path": "/curriculum/sql?unit=sql.course.foundations.04-discounted-orders-zero-defaulted-amount",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "sql.lesson.syllabus-05-give-self-joined-rows-distinct-roles-without-mirrored-",
      "subject": "sql",
      "title": "Choose one canonical ingestion for each event identity",
      "objective": "Select exactly one canonical ingestion per event with a deterministic newest-row and identity tie policy.",
      "unit_id": "sql.course.foundations.05-give-self-joined-rows-distinct-roles-without-mirrored-",
      "path": "/curriculum/sql?unit=sql.course.foundations.05-give-self-joined-rows-distinct-roles-without-mirrored-",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "sql.lesson.syllabus-06-compute-a-rolling-average-over-a-bounded-row-window",
      "subject": "sql",
      "title": "Reject invalid stored quantities while allowing lossless SQLite coercion",
      "objective": "Enforce stored quantity constraints while accepting SQLite’s declared lossless conversion into a STRICT integer column.",
      "unit_id": "sql.course.foundations.06-compute-a-rolling-average-over-a-bounded-row-window",
      "path": "/curriculum/sql?unit=sql.course.foundations.06-compute-a-rolling-average-over-a-bounded-row-window",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "sql.lesson.syllabus-07-net-amount-by-customer",
      "subject": "sql",
      "title": "Preserve a blank note while labeling missing data",
      "objective": "Replace only SQL NULL with the requested label, preserving empty text, spaces and other present content.",
      "unit_id": "sql.course.foundations.07-net-amount-by-customer",
      "path": "/curriculum/sql?unit=sql.course.foundations.07-net-amount-by-customer",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "sql.lesson.syllabus-08-unpaid-orders-distinct-amount-count-by-region",
      "subject": "sql",
      "title": "Report exact whole batches and remaining units",
      "objective": "Compute whole batches and remaining units under integer division, retaining the declared zero-divisor result.",
      "unit_id": "sql.course.foundations.08-unpaid-orders-distinct-amount-count-by-region",
      "path": "/curriculum/sql?unit=sql.course.foundations.08-unpaid-orders-distinct-amount-count-by-region",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "sql.lesson.syllabus-09-eastern-or-unassigned-regions-amount-sum-by-region",
      "subject": "sql",
      "title": "Nothing is not zero, and nothing does not equal itself",
      "objective": "Distinguish row count, known-value count and missing count without treating a stored zero as missing.",
      "unit_id": "sql.course.foundations.09-eastern-or-unassigned-regions-amount-sum-by-region",
      "path": "/curriculum/sql?unit=sql.course.foundations.09-eastern-or-unassigned-regions-amount-sum-by-region",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "sql.lesson.syllabus-10-known-amounts-amount-sum-by-customer",
      "subject": "sql",
      "title": "Keep every eligibility branch behind its required guard",
      "objective": "Place the enabled guard around the entire admin-or-score condition so no OR branch can bypass it.",
      "unit_id": "sql.course.foundations.10-known-amounts-amount-sum-by-customer",
      "path": "/curriculum/sql?unit=sql.course.foundations.10-known-amounts-amount-sum-by-customer",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "sql.lesson.syllabus-11-unpaid-orders-maximum-amount-by-status",
      "subject": "sql",
      "title": "Keeping every row and summarizing anyway",
      "objective": "Keep each detail row while computing region-local running totals and the declared tie-aware rank.",
      "unit_id": "sql.course.foundations.11-unpaid-orders-maximum-amount-by-status",
      "path": "/curriculum/sql?unit=sql.course.foundations.11-unpaid-orders-maximum-amount-by-status",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "sql.lesson.syllabus-12-paid-western-orders-minimum-amount-by-status",
      "subject": "sql",
      "title": "Aggregate the qualifying values in each group",
      "objective": "Preserve every observed group while selecting positive contributions inside its aggregate, including groups totaling zero.",
      "unit_id": "sql.course.foundations.12-paid-western-orders-minimum-amount-by-status",
      "path": "/curriculum/sql?unit=sql.course.foundations.12-paid-western-orders-minimum-amount-by-status",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "sql.lesson.syllabus-13-missing-amounts-row-count-by-region-then-status",
      "subject": "sql",
      "title": "A grouped relation can require every named capability",
      "objective": "Require both named capabilities using distinct qualifying grants rather than duplicate or unrelated permission counts.",
      "unit_id": "sql.course.foundations.13-missing-amounts-row-count-by-region-then-status",
      "path": "/curriculum/sql?unit=sql.course.foundations.13-missing-amounts-row-count-by-region-then-status",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "sql.lesson.syllabus-14-distinct-amount-count-by-region-at-least-one-missing-a",
      "subject": "sql",
      "title": "WHERE filters rows, HAVING filters groups",
      "objective": "Filter qualifying orders before grouping, then apply the separate aggregate threshold to the resulting groups.",
      "unit_id": "sql.course.foundations.14-distinct-amount-count-by-region-at-least-one-missing-a",
      "path": "/curriculum/sql?unit=sql.course.foundations.14-distinct-amount-count-by-region-at-least-one-missing-a",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "sql.lesson.syllabus-15-maximum-amount-by-status-at-least-two-orders",
      "subject": "sql",
      "title": "Preserve empty teams while filtering each aggregate independently",
      "objective": "Preserve empty parent teams and apply each metric’s eligibility rule inside its own aggregate.",
      "unit_id": "sql.course.foundations.15-maximum-amount-by-status-at-least-two-orders",
      "path": "/curriculum/sql?unit=sql.course.foundations.15-maximum-amount-by-status-at-least-two-orders",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "sql.lesson.syllabus-16-missing-amounts-matched-customer-tier",
      "subject": "sql",
      "title": "The CASE that must ask about NULL first",
      "objective": "Label missing scores explicitly and apply inclusive grade thresholds in descending order.",
      "unit_id": "sql.course.foundations.16-missing-amounts-matched-customer-tier",
      "path": "/curriculum/sql?unit=sql.course.foundations.16-missing-amounts-matched-customer-tier",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "sql.lesson.syllabus-17-known-amounts-all-customer-pro-flag",
      "subject": "sql",
      "title": "Name the middle step",
      "objective": "Name team-grain totals in a CTE and compare against their average rather than the average underlying expense.",
      "unit_id": "sql.course.foundations.17-known-amounts-all-customer-pro-flag",
      "path": "/curriculum/sql?unit=sql.course.foundations.17-known-amounts-all-customer-pro-flag",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "sql.lesson.syllabus-18-union-all-nonnegative-amounts-paid-western-orders",
      "subject": "sql",
      "title": "Null replacement must preserve empty text",
      "objective": "Substitute the missing-team label only for NULL while preserving present empty text and stable row order.",
      "unit_id": "sql.course.foundations.18-union-all-nonnegative-amounts-paid-western-orders",
      "path": "/curriculum/sql?unit=sql.course.foundations.18-union-all-nonnegative-amounts-paid-western-orders",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "sql.lesson.syllabus-19-except-refunds-eastern-or-unassigned-regions",
      "subject": "sql",
      "title": "The predicate the index can actually see",
      "objective": "Express a month as a half-open range on the indexed date column and inspect the actual SQLite access plan.",
      "unit_id": "sql.course.foundations.19-except-refunds-eastern-or-unassigned-regions",
      "path": "/curriculum/sql?unit=sql.course.foundations.19-except-refunds-eastern-or-unassigned-regions",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "sql.lesson.syllabus-20-the-full-ledger-running-total",
      "subject": "sql",
      "title": "Commit the whole command batch and its delivery intent together",
      "objective": "Commit every valid account adjustment and its immutable delivery intent in one owned transaction, rolling the whole batch back on rejection.",
      "unit_id": "sql.course.foundations.20-the-full-ledger-running-total",
      "path": "/curriculum/sql?unit=sql.course.foundations.20-the-full-ledger-running-total",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "frontend.lesson.syllabus-01-the-element-that-already-does-it",
      "subject": "frontend",
      "title": "The element that already does it",
      "objective": "Choose native links for destinations and named buttons for mutations so browser activation behavior matches the requested action.",
      "unit_id": "frontend.course.foundations.01-the-element-that-already-does-it",
      "path": "/curriculum/frontend?unit=frontend.course.foundations.01-the-element-that-already-does-it",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "frontend.lesson.syllabus-02-document-structure",
      "subject": "frontend",
      "title": "Keep navigation useful when script fails",
      "objective": "Retain a real navigation destination when enhancement is unavailable and preserve native modified-click behavior.",
      "unit_id": "frontend.course.foundations.02-document-structure",
      "path": "/curriculum/frontend?unit=frontend.course.foundations.02-document-structure",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "frontend.lesson.syllabus-03-forms-the-browser-understands",
      "subject": "frontend",
      "title": "Forms the browser understands",
      "objective": "Distinguish authored form attributes, current user values and reset defaults without replacing deliberately empty input.",
      "unit_id": "frontend.course.foundations.03-forms-the-browser-understands",
      "path": "/curriculum/frontend?unit=frontend.course.foundations.03-forms-the-browser-understands",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "frontend.lesson.syllabus-04-normal-flow",
      "subject": "frontend",
      "title": "Repair a wrap-safe command row",
      "objective": "Wrap the command row without removing actions, reversing keyboard order or covering an essential control.",
      "unit_id": "frontend.course.foundations.04-normal-flow",
      "path": "/curriculum/frontend?unit=frontend.course.foundations.04-normal-flow",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "frontend.lesson.syllabus-05-keyboard-only",
      "subject": "frontend",
      "title": "Keyboard only",
      "objective": "Move a composite tab’s keyboard entry point only among enabled tabs, preserving one active focus position.",
      "unit_id": "frontend.course.foundations.05-keyboard-only",
      "path": "/curriculum/frontend?unit=frontend.course.foundations.05-keyboard-only",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "frontend.lesson.syllabus-06-focus-after-an-action",
      "subject": "frontend",
      "title": "Focus after an action",
      "objective": "Capture the actual dialog opener and restore a usable focus destination after the dialog’s owned lifetime ends.",
      "unit_id": "frontend.course.foundations.06-focus-after-an-action",
      "path": "/curriculum/frontend?unit=frontend.course.foundations.06-focus-after-an-action",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "frontend.lesson.syllabus-07-accessible-names",
      "subject": "frontend",
      "title": "Give controls names that survive loading and error states",
      "objective": "Keep an action’s accessible name stable through loading and error states while reporting progress separately.",
      "unit_id": "frontend.course.foundations.07-accessible-names",
      "path": "/curriculum/frontend?unit=frontend.course.foundations.07-accessible-names",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "frontend.lesson.syllabus-08-grid",
      "subject": "frontend",
      "title": "Keep enlarged text and long results reachable",
      "objective": "Assign bounded scrolling to the result pane while preserving document access to enlarged instructions and controls.",
      "unit_id": "frontend.course.foundations.08-grid",
      "path": "/curriculum/frontend?unit=frontend.course.foundations.08-grid",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "frontend.lesson.syllabus-09-responsive-without-breakpoints",
      "subject": "frontend",
      "title": "Keep fallback typography readable during loading",
      "objective": "Keep readable fallback text available and evaluate geometry changes independently of font download completion.",
      "unit_id": "frontend.course.foundations.09-responsive-without-breakpoints",
      "path": "/curriculum/frontend?unit=frontend.course.foundations.09-responsive-without-breakpoints",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "frontend.lesson.syllabus-10-the-text-that-was-longer",
      "subject": "frontend",
      "title": "Restore filters with the browser Back button",
      "objective": "Restore URL-backed filters on Back traversal without creating another history entry or replacing unrelated query choices.",
      "unit_id": "frontend.course.foundations.10-the-text-that-was-longer",
      "path": "/curriculum/frontend?unit=frontend.course.foundations.10-the-text-that-was-longer",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "frontend.lesson.syllabus-11-measuring",
      "subject": "frontend",
      "title": "Measuring",
      "objective": "Compare the first useful interaction’s measured evidence under one controlled workload before selecting an optimization.",
      "unit_id": "frontend.course.foundations.11-measuring",
      "path": "/curriculum/frontend?unit=frontend.course.foundations.11-measuring",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "frontend.lesson.syllabus-12-animating-the-cheap-properties",
      "subject": "frontend",
      "title": "Animating the cheap properties",
      "objective": "Collect geometry reads before DOM writes so later measurements do not repeatedly force pending layout.",
      "unit_id": "frontend.course.foundations.12-animating-the-cheap-properties",
      "path": "/curriculum/frontend?unit=frontend.course.foundations.12-animating-the-cheap-properties",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "frontend.lesson.syllabus-13-what-is-in-the-bundle",
      "subject": "frontend",
      "title": "What is in the bundle",
      "objective": "Keep startup-critical action dependencies on the initial path while deferring genuinely optional work.",
      "unit_id": "frontend.course.foundations.13-what-is-in-the-bundle",
      "path": "/curriculum/frontend?unit=frontend.course.foundations.13-what-is-in-the-bundle",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "frontend.lesson.syllabus-14-the-font-that-hid-the-text",
      "subject": "frontend",
      "title": "Choose an image source for the actual rendered slot",
      "objective": "Choose an image candidate from its rendered slot and pixel density while reserving the displayed geometry.",
      "unit_id": "frontend.course.foundations.14-the-font-that-hid-the-text",
      "path": "/curriculum/frontend?unit=frontend.course.foundations.14-the-font-that-hid-the-text",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "frontend.lesson.syllabus-15-the-focus-trap",
      "subject": "frontend",
      "title": "Hand form errors to the controls that own them",
      "objective": "Hand a submitted form’s errors to linked controls in a stable order without competing focus and status announcements.",
      "unit_id": "frontend.course.foundations.15-the-focus-trap",
      "path": "/curriculum/frontend?unit=frontend.course.foundations.15-the-focus-trap",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "frontend.lesson.syllabus-16-announcing-a-change",
      "subject": "frontend",
      "title": "Announcing a change",
      "objective": "Distinguish pending and locally queued saves from server acceptance, preserving edits during offline work.",
      "unit_id": "frontend.course.foundations.16-announcing-a-change",
      "path": "/curriculum/frontend?unit=frontend.course.foundations.16-announcing-a-change",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "frontend.lesson.syllabus-17-server-state-is-not-client-state",
      "subject": "frontend",
      "title": "Repair authorization across client and server",
      "objective": "Recheck permission at the current server authority rather than treating cached client visibility as authorization.",
      "unit_id": "frontend.course.foundations.17-server-state-is-not-client-state",
      "path": "/curriculum/frontend?unit=frontend.course.foundations.17-server-state-is-not-client-state",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "frontend.lesson.syllabus-18-layout-thrash",
      "subject": "frontend",
      "title": "Choose containment without breaking content",
      "objective": "Choose containment only where its size and paint boundaries preserve required content and scroll access.",
      "unit_id": "frontend.course.foundations.18-layout-thrash",
      "path": "/curriculum/frontend?unit=frontend.course.foundations.18-layout-thrash",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "frontend.lesson.syllabus-19-the-critical-path",
      "subject": "frontend",
      "title": "Separate readable fallback from layout-shift evidence",
      "objective": "Compare fallback readability and observed layout shift before selecting a font-loading policy.",
      "unit_id": "frontend.course.foundations.19-the-critical-path",
      "path": "/curriculum/frontend?unit=frontend.course.foundations.19-the-critical-path",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "frontend.lesson.syllabus-20-optimistic-updates",
      "subject": "frontend",
      "title": "Reconcile an optimistic edit by revision",
      "objective": "Roll back an optimistic edit only while that operation still owns the visible revision.",
      "unit_id": "frontend.course.foundations.20-optimistic-updates",
      "path": "/curriculum/frontend?unit=frontend.course.foundations.20-optimistic-updates",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "react.lesson.syllabus-01-a-component-is-a-function",
      "subject": "react",
      "title": "Render a field with stable label and error relationships",
      "objective": "Render a stable label/control/error relationship with unique linked identities and ordinary escaped error text.",
      "unit_id": "react.course.foundations.01-a-component-is-a-function",
      "path": "/curriculum/react?unit=react.course.foundations.01-a-component-is-a-function",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "react.lesson.syllabus-02-conditional-rendering",
      "subject": "react",
      "title": "One state, two views of it",
      "objective": "Keep one canonical input state while deriving consistent rendered views instead of separately storing values that must agree.",
      "unit_id": "react.course.foundations.02-conditional-rendering",
      "path": "/curriculum/react?unit=react.course.foundations.02-conditional-rendering",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "react.lesson.syllabus-03-keep-profile-navigation-distinct-from-mutations",
      "subject": "react",
      "title": "Keep profile navigation distinct from mutations",
      "objective": "Use a native link for profile navigation and buttons for mutations, preserving their distinct activation semantics.",
      "unit_id": "react.course.foundations.03-keep-profile-navigation-distinct-from-mutations",
      "path": "/curriculum/react?unit=react.course.foundations.03-keep-profile-navigation-distinct-from-mutations",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "react.lesson.syllabus-04-derived-state",
      "subject": "react",
      "title": "Separate accepted baseline from an edited draft",
      "objective": "Keep the accepted baseline distinct from the current editable draft and calculate dirty state from their actual values.",
      "unit_id": "react.course.foundations.04-derived-state",
      "path": "/curriculum/react?unit=react.course.foundations.04-derived-state",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "react.lesson.syllabus-05-compose-explicit-heading-body-and-footer-slots",
      "subject": "react",
      "title": "Test what the user gets, not how you built it",
      "objective": "Test the rendered behavior a user can observe rather than coupling assertions to private component implementation details.",
      "unit_id": "react.course.foundations.05-compose-explicit-heading-body-and-footer-slots",
      "path": "/curriculum/react?unit=react.course.foundations.05-compose-explicit-heading-body-and-footer-slots",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "react.lesson.syllabus-06-reject-unstable-list-identity",
      "subject": "react",
      "title": "Toggle checkbox membership without duplicate identities",
      "objective": "Toggle checkbox membership by exact identity without duplicate entries or mutation of the caller’s collection.",
      "unit_id": "react.course.foundations.06-reject-unstable-list-identity",
      "path": "/curriculum/react?unit=react.course.foundations.06-reject-unstable-list-identity",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "react.lesson.syllabus-07-dispose-the-owned-subscription-once",
      "subject": "react",
      "title": "The answer that arrives after you stopped asking",
      "objective": "Publish an asynchronous result only while its request still owns the resource generation.",
      "unit_id": "react.course.foundations.07-dispose-the-owned-subscription-once",
      "path": "/curriculum/react?unit=react.course.foundations.07-dispose-the-owned-subscription-once",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "react.lesson.syllabus-08-compose-a-panel-through-named-slots",
      "subject": "react",
      "title": "Reconcile ordered entity state without stale selection",
      "objective": "Reconcile ordered entity identities and selection without retaining a selected record that was removed.",
      "unit_id": "react.course.foundations.08-compose-a-panel-through-named-slots",
      "path": "/curriculum/react?unit=react.course.foundations.08-compose-a-panel-through-named-slots",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "react.lesson.syllabus-09-batch-independent-deltas-without-conflating-resets",
      "subject": "react",
      "title": "Keep browser-only affordances outside server markup",
      "objective": "Render a stable server-safe representation before introducing browser-only affordances in a later lifetime.",
      "unit_id": "react.course.foundations.09-batch-independent-deltas-without-conflating-resets",
      "path": "/curriculum/react?unit=react.course.foundations.09-batch-independent-deltas-without-conflating-resets",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "react.lesson.syllabus-10-own-a-mounted-effect-and-keep-server-rendering-pure",
      "subject": "react",
      "title": "State that cannot disagree with itself",
      "objective": "Represent mutually exclusive resource states explicitly so loading, accepted value and failure cannot contradict each other.",
      "unit_id": "react.course.foundations.10-own-a-mounted-effect-and-keep-server-rendering-pure",
      "path": "/curriculum/react?unit=react.course.foundations.10-own-a-mounted-effect-and-keep-server-rendering-pure",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "react.lesson.syllabus-11-the-effect-that-should-not-exist",
      "subject": "react",
      "title": "Compare effect dependencies with their actual equality rule",
      "objective": "Connect an effect’s lifetime to its dependencies and compare values with Object.is rather than recursive equality.",
      "unit_id": "react.course.foundations.11-the-effect-that-should-not-exist",
      "path": "/curriculum/react?unit=react.course.foundations.11-the-effect-that-should-not-exist",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "react.lesson.syllabus-12-loading-loaded-failed",
      "subject": "react",
      "title": "Render failure and retry identity without inventing recovery evidence",
      "objective": "Choose the declared current resource view before rendering a failure fallback with an explicit retry identity.",
      "unit_id": "react.course.foundations.12-loading-loaded-failed",
      "path": "/curriculum/react?unit=react.course.foundations.12-loading-loaded-failed",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "react.lesson.syllabus-13-acquire-a-default-only-for-an-absent-initialized-value",
      "subject": "react",
      "title": "Choose a connected opener before a safe fallback",
      "objective": "Restore focus to a still-connected usable opener, then choose a safe fallback without stealing an independently moved focus.",
      "unit_id": "react.course.foundations.13-acquire-a-default-only-for-an-absent-initialized-value",
      "path": "/curriculum/react?unit=react.course.foundations.13-acquire-a-default-only-for-an-absent-initialized-value",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "react.lesson.syllabus-14-keep-provider-values-isolated-between-renders",
      "subject": "react",
      "title": "Restore the outer provider after an inner scope",
      "objective": "Install an inner provider only for its owned scope and restore the exact outer value on every exit path.",
      "unit_id": "react.course.foundations.14-keep-provider-values-isolated-between-renders",
      "path": "/curriculum/react?unit=react.course.foundations.14-keep-provider-values-isolated-between-renders",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "react.lesson.syllabus-15-serialize-hydration-data-inside-a-non-executing-script",
      "subject": "react",
      "title": "Reset only after confirming the accepted revision",
      "objective": "Reset a draft only when the accepted baseline revision still matches the reset request; keep hydration serialization as its separately stated security boundary.",
      "unit_id": "react.course.foundations.15-serialize-hydration-data-inside-a-non-executing-script",
      "path": "/curriculum/react?unit=react.course.foundations.15-serialize-hydration-data-inside-a-non-executing-script",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "react.lesson.syllabus-16-keep-failures-attached-to-their-resource-generation",
      "subject": "react",
      "title": "Keep one active submit operation and reconcile its result",
      "objective": "Own one asynchronous submit operation and reconcile its accepted result without discarding edits made while it was pending.",
      "unit_id": "react.course.foundations.16-keep-failures-attached-to-their-resource-generation",
      "path": "/curriculum/react?unit=react.course.foundations.16-keep-failures-attached-to-their-resource-generation",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "react.lesson.syllabus-17-roll-back-partially-acquired-effect-resources",
      "subject": "react",
      "title": "Replace an effect lifetime without overlapping resources",
      "objective": "Release the previous effect lifetime before acquiring its replacement and retain correct ownership after setup failure.",
      "unit_id": "react.course.foundations.17-roll-back-partially-acquired-effect-resources",
      "path": "/curriculum/react?unit=react.course.foundations.17-roll-back-partially-acquired-effect-resources",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "react.lesson.syllabus-18-guard-publication-across-a-queued-microtask",
      "subject": "react",
      "title": "Keep the previous value when preparation fails",
      "objective": "Prepare a replacement value before publishing it so a failed preparation leaves the previously accepted value unchanged.",
      "unit_id": "react.course.foundations.18-guard-publication-across-a-queued-microtask",
      "path": "/curriculum/react?unit=react.course.foundations.18-guard-publication-across-a-queued-microtask",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "react.lesson.syllabus-19-publish-related-state-before-notifying-each-observer",
      "subject": "react",
      "title": "Release a temporary work resource after success or failure",
      "objective": "Hold an acquired temporary resource until asynchronous work settles, then release it once after success or failure.",
      "unit_id": "react.course.foundations.19-publish-related-state-before-notifying-each-observer",
      "path": "/curriculum/react?unit=react.course.foundations.19-publish-related-state-before-notifying-each-observer",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "react.lesson.syllabus-20-memo-and-measuring-first",
      "subject": "react",
      "title": "Reuse a derivation only for the same input identity",
      "objective": "Reuse a derived result only for the same immutable input identity and cache no identity whose computation failed.",
      "unit_id": "react.course.foundations.20-memo-and-measuring-first",
      "path": "/curriculum/react?unit=react.course.foundations.20-memo-and-measuring-first",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "angular.lesson.syllabus-01-a-component",
      "subject": "angular",
      "title": "Update one owned row using a new input identity",
      "objective": "Update one selected row through new array and record identities while retaining unaffected records and no-op identity.",
      "unit_id": "angular.course.foundations.01-a-component",
      "path": "/curriculum/angular?unit=angular.course.foundations.01-a-component",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "angular.lesson.syllabus-02-place-parent-owned-slots-without-overriding-content",
      "subject": "angular",
      "title": "Patch one query value without dropping unrelated keys",
      "objective": "Change one query parameter without dropping unrelated or repeated values, distinguishing removal from present empty text.",
      "unit_id": "angular.course.foundations.02-place-parent-owned-slots-without-overriding-content",
      "path": "/curriculum/angular?unit=angular.course.foundations.02-place-parent-owned-slots-without-overriding-content",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "angular.lesson.syllabus-03-emit-a-selection-command-without-taking-parent-ownersh",
      "subject": "angular",
      "title": "Construct matching host attribute and property state",
      "objective": "Construct matching boolean host-property and ARIA-attribute records without turning absent attributes into misleading text.",
      "unit_id": "angular.course.foundations.03-emit-a-selection-command-without-taking-parent-ownersh",
      "path": "/curriculum/angular?unit=angular.course.foundations.03-emit-a-selection-command-without-taking-parent-ownersh",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "angular.lesson.syllabus-04-queue-view-work-only-inside-an-available-lifetime",
      "subject": "angular",
      "title": "The order Angular calls you in",
      "objective": "Run initial input changes before initialization, repeat changes without reinitializing and destroy the controlled lifecycle once.",
      "unit_id": "angular.course.foundations.04-queue-view-work-only-inside-an-available-lifetime",
      "path": "/curriculum/angular?unit=angular.course.foundations.04-queue-view-work-only-inside-an-available-lifetime",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "angular.lesson.syllabus-05-an-observable-is-not-a-promise",
      "subject": "angular",
      "title": "Return enabled and complete form representations",
      "objective": "Return separate enabled-only and complete form representations without sharing their mutable output containers.",
      "unit_id": "angular.course.foundations.05-an-observable-is-not-a-promise",
      "path": "/curriculum/angular?unit=angular.course.foundations.05-an-observable-is-not-a-promise",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "angular.lesson.syllabus-06-suppress-adjacent-duplicates-without-global-deduplicat",
      "subject": "angular",
      "title": "Suppress adjacent duplicates without global deduplication",
      "objective": "Suppress only adjacent Object.is-equal stream values, retaining a repeated value that returns after a different value.",
      "unit_id": "angular.course.foundations.06-suppress-adjacent-duplicates-without-global-deduplicat",
      "path": "/curriculum/angular?unit=angular.course.foundations.06-suppress-adjacent-duplicates-without-global-deduplicat",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "angular.lesson.syllabus-07-navigation-policy-still-needs-server-authorization",
      "subject": "angular",
      "title": "Every request through the same doors",
      "objective": "Construct the declared request URL and headers immutably while preserving original request ownership.",
      "unit_id": "angular.course.foundations.07-navigation-policy-still-needs-server-authorization",
      "path": "/curriculum/angular?unit=angular.course.foundations.07-navigation-policy-still-needs-server-authorization",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "angular.lesson.syllabus-08-subscription-cleanup-owns-every-disposer",
      "subject": "angular",
      "title": "Subscription cleanup owns every disposer",
      "objective": "Consume acquired subscription disposers in reverse order, continue after failure and make repeated teardown a no-op.",
      "unit_id": "angular.course.foundations.08-subscription-cleanup-owns-every-disposer",
      "path": "/curriculum/angular?unit=angular.course.foundations.08-subscription-cleanup-owns-every-disposer",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "angular.lesson.syllabus-09-attach-remote-errors-to-the-submitted-revision",
      "subject": "angular",
      "title": "Move dynamic controls by stable identity",
      "objective": "Move a dynamic control by stable identity while preserving its record state and rejecting an invalid destination before publication.",
      "unit_id": "angular.course.foundations.09-attach-remote-errors-to-the-submitted-revision",
      "path": "/curriculum/angular?unit=angular.course.foundations.09-attach-remote-errors-to-the-submitted-revision",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "angular.lesson.syllabus-10-isolate-service-state-across-scope-lifetimes",
      "subject": "angular",
      "title": "Isolate service state across scope lifetimes",
      "objective": "Keep captured service state independent across scopes and reject changes after that scope has closed.",
      "unit_id": "angular.course.foundations.10-isolate-service-state-across-scope-lifetimes",
      "path": "/curriculum/angular?unit=angular.course.foundations.10-isolate-service-state-across-scope-lifetimes",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "angular.lesson.syllabus-11-separate-emitted-values-from-terminal-completion",
      "subject": "angular",
      "title": "Replay a retained value only under the declared policy",
      "objective": "Replay a last emitted value only under the declared retention policy, distinguishing stored zero from no prior emission.",
      "unit_id": "angular.course.foundations.11-separate-emitted-values-from-terminal-completion",
      "path": "/curriculum/angular?unit=angular.course.foundations.11-separate-emitted-values-from-terminal-completion",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "angular.lesson.syllabus-12-reset-route-specific-state-while-retaining-shared-pref",
      "subject": "angular",
      "title": "Project safe request diagnostics",
      "objective": "Project safe request diagnostics through the declared field boundary without exporting body content or authorization.",
      "unit_id": "angular.course.foundations.12-reset-route-specific-state-while-retaining-shared-pref",
      "path": "/curriculum/angular?unit=angular.course.foundations.12-reset-route-specific-state-while-retaining-shared-pref",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "angular.lesson.syllabus-13-content-projection",
      "subject": "angular",
      "title": "An injector with nothing up its sleeve",
      "objective": "Resolve the supplied injector’s registered factory lazily and reuse its accepted instance instead of constructing it at registration.",
      "unit_id": "angular.course.foundations.13-content-projection",
      "path": "/curriculum/angular?unit=angular.course.foundations.13-content-projection",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "angular.lesson.syllabus-14-update-one-owned-row-using-a-new-input-identity",
      "subject": "angular",
      "title": "Select an optimization only from attributable workload evidence",
      "objective": "Select a performance hypothesis from attributable workload totals using the declared tie policy, without inventing repair evidence.",
      "unit_id": "angular.course.foundations.14-update-one-owned-row-using-a-new-input-identity",
      "path": "/curriculum/angular?unit=angular.course.foundations.14-update-one-owned-row-using-a-new-input-identity",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "angular.lesson.syllabus-15-signals",
      "subject": "angular",
      "title": "Own a producer through one subscription lifetime",
      "objective": "Route producer values only through a live subscription and run its acquired cleanup once when that lifetime ends.",
      "unit_id": "angular.course.foundations.15-signals",
      "path": "/curriculum/angular?unit=angular.course.foundations.15-signals",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "angular.lesson.syllabus-16-state-without-a-store",
      "subject": "angular",
      "title": "Bound producer backlog and account for active work",
      "objective": "Bound pending queue capacity independently of its single active job and account for both owners until completion.",
      "unit_id": "angular.course.foundations.16-state-without-a-store",
      "path": "/curriculum/angular?unit=angular.course.foundations.16-state-without-a-store",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "angular.lesson.syllabus-17-publish-related-state-before-notifying-observers",
      "subject": "angular",
      "title": "Acquire one service on demand and retry failed creation",
      "objective": "Acquire a service on demand, retry a failed creation and cache successful undefined separately from uninitialized state.",
      "unit_id": "angular.course.foundations.17-publish-related-state-before-notifying-observers",
      "path": "/curriculum/angular?unit=angular.course.foundations.17-publish-related-state-before-notifying-observers",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "angular.lesson.syllabus-18-retry-one-operation-within-its-explicit-attempt-budget",
      "subject": "angular",
      "title": "Fence resolver publication to the requested navigation",
      "objective": "Attach every resolver publication to its navigation generation so an older result cannot replace the accepted current value.",
      "unit_id": "angular.course.foundations.18-retry-one-operation-within-its-explicit-attempt-budget",
      "path": "/curriculum/angular?unit=angular.course.foundations.18-retry-one-operation-within-its-explicit-attempt-budget",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "angular.lesson.syllabus-19-abort-only-the-request-owned-by-the-destroyed-consumer",
      "subject": "angular",
      "title": "Abort only the request owned by the destroyed consumer",
      "objective": "Abort only requests acquired by this consumer and permanently reject new work after its owned lifetime ends.",
      "unit_id": "angular.course.foundations.19-abort-only-the-request-owned-by-the-destroyed-consumer",
      "path": "/curriculum/angular?unit=angular.course.foundations.19-abort-only-the-request-owned-by-the-destroyed-consumer",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "angular.lesson.syllabus-20-a-screen-end-to-end",
      "subject": "angular",
      "title": "Key cached responses by every declared varying input",
      "objective": "Encode every declared response-varying input in an unambiguous cache tuple, preserving absent and empty identity separately.",
      "unit_id": "angular.course.foundations.20-a-screen-end-to-end",
      "path": "/curriculum/angular?unit=angular.course.foundations.20-a-screen-end-to-end",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "php.lesson.value-and-type-behavior",
      "subject": "php",
      "title": "Accept exact PHP values at the boundary",
      "objective": "Distinguish runtime type, lexical transport form, presence and truthiness before a value reaches domain work.",
      "unit_id": "php.course.foundations.01-value-and-type-behavior",
      "path": "/curriculum/php?unit=php.course.foundations.01-value-and-type-behavior",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "php.lesson.collections-and-functions",
      "subject": "php",
      "title": "Preserve PHP collection shape and callback intent",
      "objective": "Keep list shape, identity keys, stable order and callable arguments intact across collection transforms.",
      "unit_id": "php.course.foundations.02-collections-and-functions",
      "path": "/curriculum/php?unit=php.course.foundations.02-collections-and-functions",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "php.lesson.text-and-json",
      "subject": "php",
      "title": "Validate complete text before decoding JSON",
      "objective": "Keep byte budgets, Unicode validity, JSON syntax and decoded root shape as separate boundary decisions.",
      "unit_id": "php.course.foundations.03-text-and-json",
      "path": "/curriculum/php?unit=php.course.foundations.03-text-and-json",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "php.lesson.request-and-output",
      "subject": "php",
      "title": "Turn one request into one safe response",
      "objective": "Resolve method, repeated input, header and output-context policy before executing a request command.",
      "unit_id": "php.course.foundations.04-request-and-output",
      "path": "/curriculum/php?unit=php.course.foundations.04-request-and-output",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "php.lesson.enums-and-exhaustive-policy",
      "subject": "php",
      "title": "Make PHP state policy exhaustive",
      "objective": "Decode backed enums safely and keep transport values, case names and exhaustive match policy distinct.",
      "unit_id": "php.course.foundations.05-enums-and-exhaustive-policy",
      "path": "/curriculum/php?unit=php.course.foundations.05-enums-and-exhaustive-policy",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "php.lesson.callables-and-capture",
      "subject": "php",
      "title": "Preserve PHP callable and capture contracts",
      "objective": "Choose snapshot or live scalar capture deliberately, then preserve that time policy in a changed predicate contract.",
      "unit_id": "php.course.foundations.06-callables-and-capture",
      "path": "/curriculum/php?unit=php.course.foundations.06-callables-and-capture",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "php.lesson.prepared-data-boundaries",
      "subject": "php",
      "title": "Keep SQL code separate from PHP data",
      "objective": "Bind values through the statement contract, preserve placeholder shape and close result cursors owned by the operation.",
      "unit_id": "php.course.foundations.07-prepared-data-boundaries",
      "path": "/curriculum/php?unit=php.course.foundations.07-prepared-data-boundaries",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "php.lesson.failure-and-resources",
      "subject": "php",
      "title": "Unwind only the PHP resources you acquired",
      "objective": "Preserve the primary failure, release each acquired resource and avoid committing or rolling back a caller-owned scope.",
      "unit_id": "php.course.foundations.08-failure-and-resources",
      "path": "/curriculum/php?unit=php.course.foundations.08-failure-and-resources",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "php.lesson.time-and-money",
      "subject": "php",
      "title": "Keep time and money exact",
      "objective": "Parse explicit time zones and decimal money without machine-local defaults or binary floating conversion.",
      "unit_id": "php.course.foundations.09-time-and-money",
      "path": "/curriculum/php?unit=php.course.foundations.09-time-and-money",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "php.lesson.objects-and-readonly",
      "subject": "php",
      "title": "Define honest PHP object ownership",
      "objective": "Construct typed objects completely, expose readonly scalar state and clone only mutable children the object owns.",
      "unit_id": "php.course.foundations.10-objects-and-readonly",
      "path": "/curriculum/php?unit=php.course.foundations.10-objects-and-readonly",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "php.lesson.generators-and-lazy-work",
      "subject": "php",
      "title": "Own lazy PHP iteration through completion",
      "objective": "Consume a single-use iterable once, catch failures at execution and close a privately owned suspended generator.",
      "unit_id": "php.course.foundations.11-generators-and-lazy-work",
      "path": "/curriculum/php?unit=php.course.foundations.11-generators-and-lazy-work",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "php.lesson.file-acquisition-and-publication",
      "subject": "php",
      "title": "Publish complete PHP files from owned stages",
      "objective": "Acquire paths without check-then-create races, contain targets and publish only fully written owned files.",
      "unit_id": "php.course.foundations.12-file-acquisition-and-publication",
      "path": "/curriculum/php?unit=php.course.foundations.12-file-acquisition-and-publication",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "php.lesson.sessions-cookies-and-csrf",
      "subject": "php",
      "title": "Bind browser state to the intended session",
      "objective": "Rotate authenticated sessions, configure complete cookie policy and verify a session-bound CSRF token.",
      "unit_id": "php.course.foundations.13-sessions-cookies-and-csrf",
      "path": "/curriculum/php?unit=php.course.foundations.13-sessions-cookies-and-csrf",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "php.lesson.pagination-and-negotiation",
      "subject": "php",
      "title": "Version continuation and representation policy",
      "objective": "Treat cursors as versioned data and resolve response representation by explicit media specificity.",
      "unit_id": "php.course.foundations.14-pagination-and-negotiation",
      "path": "/curriculum/php?unit=php.course.foundations.14-pagination-and-negotiation",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "php.lesson.diagnostics-and-failure-testing",
      "subject": "php",
      "title": "Test PHP failures without leaking process policy",
      "objective": "Inject controlled failures, restore process-wide handlers and expose stable diagnostics without invoking attacker objects.",
      "unit_id": "php.course.foundations.15-diagnostics-and-failure-testing",
      "path": "/curriculum/php?unit=php.course.foundations.15-diagnostics-and-failure-testing",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "php.lesson.metadata-traits-and-modules",
      "subject": "php",
      "title": "Resolve PHP metadata without hidden execution",
      "objective": "Choose trait conflicts, namespaces and attribute metadata explicitly without executing constructors during inspection.",
      "unit_id": "php.course.foundations.16-metadata-traits-and-modules",
      "path": "/curriculum/php?unit=php.course.foundations.16-metadata-traits-and-modules",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "php.lesson.request-feature-transfer",
      "subject": "php",
      "title": "Ship a complete PHP request feature",
      "objective": "Combine request validation, prepared data access, bounded diagnostics and context-safe output in one feature boundary.",
      "unit_id": "php.course.foundations.17-request-feature-transfer",
      "path": "/curriculum/php?unit=php.course.foundations.17-request-feature-transfer",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "php.lesson.transactions-and-concurrency",
      "subject": "php",
      "title": "Commit related PHP state once",
      "objective": "Guard optimistic writes in the mutation and commit domain state with its delivery intent atomically.",
      "unit_id": "php.course.foundations.18-transactions-and-concurrency",
      "path": "/curriculum/php?unit=php.course.foundations.18-transactions-and-concurrency",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "php.lesson.authentication-and-tokens",
      "subject": "php",
      "title": "Authenticate bytes before interpreting data",
      "objective": "Verify passwords, signed payloads and random tokens using standard cryptographic boundaries and canonical bytes.",
      "unit_id": "php.course.foundations.19-authentication-and-tokens",
      "path": "/curriculum/php?unit=php.course.foundations.19-authentication-and-tokens",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "php.lesson.service-publication-capstone",
      "subject": "php",
      "title": "Publish a recoverable PHP service operation",
      "objective": "Integrate authenticated input, checked state change, transaction ownership and complete publication with recoverable failure.",
      "unit_id": "php.course.foundations.20-service-publication-capstone",
      "path": "/curriculum/php?unit=php.course.foundations.20-service-publication-capstone",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "backend.lesson.syllabus-01-designing-an-interface",
      "subject": "backend",
      "title": "Keep a crawler from creating reservations",
      "objective": "Reject an unsafe state-changing use of a safe HTTP method before accepting any reservation effect.",
      "unit_id": "backend.course.foundations.01-designing-an-interface",
      "path": "/curriculum/backend?unit=backend.course.foundations.01-designing-an-interface",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "backend.lesson.syllabus-02-distinguish-absent-fields-from-explicit-null-updates",
      "subject": "backend",
      "title": "Reject an unsupported export representation early",
      "objective": "Reject an unsupported representation before acquiring or constructing an export body.",
      "unit_id": "backend.course.foundations.02-distinguish-absent-fields-from-explicit-null-updates",
      "path": "/curriculum/backend?unit=backend.course.foundations.02-distinguish-absent-fields-from-explicit-null-updates",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "backend.lesson.syllabus-03-choose-a-redirect-that-preserves-the-intended-method",
      "subject": "backend",
      "title": "Keep a supplied filter operator outside the query language",
      "objective": "Translate only allowlisted filter operators so caller values cannot extend the query language.",
      "unit_id": "backend.course.foundations.03-choose-a-redirect-that-preserves-the-intended-method",
      "path": "/curriculum/backend?unit=backend.course.foundations.03-choose-a-redirect-that-preserves-the-intended-method",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "backend.lesson.syllabus-04-authorize-the-specific-object-after-establishing-ident",
      "subject": "backend",
      "title": "Reject an unrelated site changing a cookie-authenticated record",
      "objective": "Validate the intended request origin before a cookie-authenticated mutation, rejecting ambiguous or unrelated origins.",
      "unit_id": "backend.course.foundations.04-authorize-the-specific-object-after-establishing-ident",
      "path": "/curriculum/backend?unit=backend.course.foundations.04-authorize-the-specific-object-after-establishing-ident",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "backend.lesson.syllabus-05-modeling",
      "subject": "backend",
      "title": "Keep a membership from outliving its missing owner",
      "objective": "Keep a stored membership tied to an existing owner through the actual relationship constraint.",
      "unit_id": "backend.course.foundations.05-modeling",
      "path": "/curriculum/backend?unit=backend.course.foundations.05-modeling",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "backend.lesson.syllabus-06-represent-exact-currency-amounts-without-binary-roundi",
      "subject": "backend",
      "title": "Prepare a remote quote without holding a scarce transaction",
      "objective": "Acquire a remote quote before opening the scarce local transaction that commits its checked result.",
      "unit_id": "backend.course.foundations.06-represent-exact-currency-amounts-without-binary-roundi",
      "path": "/curriculum/backend?unit=backend.course.foundations.06-represent-exact-currency-amounts-without-binary-roundi",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "backend.lesson.syllabus-07-bound-metric-labels-independently-of-request-volume",
      "subject": "backend",
      "title": "Refuse a page cursor borrowed from another search",
      "objective": "Bind a continuation cursor to the original search scope rather than accepting a cursor borrowed from another query.",
      "unit_id": "backend.course.foundations.07-bound-metric-labels-independently-of-request-volume",
      "path": "/curriculum/backend?unit=backend.course.foundations.07-bound-metric-labels-independently-of-request-volume",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "backend.lesson.syllabus-08-reject-reuse-of-an-idempotency-key-for-a-different-pay",
      "subject": "backend",
      "title": "Stop a two-account transfer from forming a lock cycle",
      "objective": "Acquire account locks in one shared ordering so two opposite transfers cannot form a lock cycle.",
      "unit_id": "backend.course.foundations.08-reject-reuse-of-an-idempotency-key-for-a-different-pay",
      "path": "/curriculum/backend?unit=backend.course.foundations.08-reject-reuse-of-an-idempotency-key-for-a-different-pay",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "backend.lesson.syllabus-09-keep-every-data-lookup-inside-the-authenticated-tenant",
      "subject": "backend",
      "title": "Keep tenant scope on storage and cached results",
      "objective": "Include authenticated tenant scope in both storage lookup and cache identity.",
      "unit_id": "backend.course.foundations.09-keep-every-data-lookup-inside-the-authenticated-tenant",
      "path": "/curriculum/backend?unit=backend.course.foundations.09-keep-every-data-lookup-inside-the-authenticated-tenant",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "backend.lesson.syllabus-10-compare-observed-bad-events-with-an-explicit-service-o",
      "subject": "backend",
      "title": "Decide a rollout from bad events in the declared window",
      "objective": "Evaluate the declared bad-event budget over the correct eligible window instead of an unrelated aggregate.",
      "unit_id": "backend.course.foundations.10-compare-observed-bad-events-with-an-explicit-service-o",
      "path": "/curriculum/backend?unit=backend.course.foundations.10-compare-observed-bad-events-with-an-explicit-service-o",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "backend.lesson.syllabus-11-transaction-boundaries",
      "subject": "backend",
      "title": "Publish one validated configuration revision to every request",
      "objective": "Validate a complete configuration before atomically publishing one revision to every request owner.",
      "unit_id": "backend.course.foundations.11-transaction-boundaries",
      "path": "/curriculum/backend?unit=backend.course.foundations.11-transaction-boundaries",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "backend.lesson.syllabus-12-retry-transient-failures-without-replaying-permanent-e",
      "subject": "backend",
      "title": "Choose the declared overflow policy without growing memory",
      "objective": "Apply the declared bounded-queue overflow policy without silently accepting an unbounded memory obligation.",
      "unit_id": "backend.course.foundations.12-retry-transient-failures-without-replaying-permanent-e",
      "path": "/curriculum/backend?unit=backend.course.foundations.12-retry-transient-failures-without-replaying-permanent-e",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "backend.lesson.syllabus-13-respect-a-retry-after-delay-within-the-remaining-budge",
      "subject": "backend",
      "title": "Spread a retry wave while respecting its cap",
      "objective": "Spread retry attempts under the stated jitter and cap policy without exceeding the permitted delay.",
      "unit_id": "backend.course.foundations.13-respect-a-retry-after-delay-within-the-remaining-budge",
      "path": "/curriculum/backend?unit=backend.course.foundations.13-respect-a-retry-after-delay-within-the-remaining-budge",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "backend.lesson.syllabus-14-metrics-that-answer-a-question",
      "subject": "backend",
      "title": "Locate the slow minority hidden by an acceptable median",
      "objective": "Locate the slow minority in the supplied latency distribution instead of accepting a favorable median.",
      "unit_id": "backend.course.foundations.14-metrics-that-answer-a-question",
      "path": "/curriculum/backend?unit=backend.course.foundations.14-metrics-that-answer-a-question",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "backend.lesson.syllabus-15-stop-downstream-work-when-its-owner-cancels",
      "subject": "backend",
      "title": "Drain accepted work before releasing service resources",
      "objective": "Withdraw admission before draining accepted work and release service resources only after the owned drain settles.",
      "unit_id": "backend.course.foundations.15-stop-downstream-work-when-its-owner-cancels",
      "path": "/curriculum/backend?unit=backend.course.foundations.15-stop-downstream-work-when-its-owner-cancels",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "backend.lesson.syllabus-16-validate-size-and-content-before-publishing-an-uploade",
      "subject": "backend",
      "title": "Keep an unvalidated upload outside the public object namespace",
      "objective": "Hold unvalidated uploaded bytes outside the public namespace and publish only a checked accepted object.",
      "unit_id": "backend.course.foundations.16-validate-size-and-content-before-publishing-an-uploade",
      "path": "/curriculum/backend?unit=backend.course.foundations.16-validate-size-and-content-before-publishing-an-uploade",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "backend.lesson.syllabus-17-prevent-two-rollout-coordinators-from-conflicting",
      "subject": "backend",
      "title": "Fence an old rollout coordinator after leadership changes",
      "objective": "Fence rollout publication to the current coordinator token so a replaced leader cannot overwrite accepted state.",
      "unit_id": "backend.course.foundations.17-prevent-two-rollout-coordinators-from-conflicting",
      "path": "/curriculum/backend?unit=backend.course.foundations.17-prevent-two-rollout-coordinators-from-conflicting",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "backend.lesson.syllabus-18-what-they-may-do",
      "subject": "backend",
      "title": "Report partial batch acceptance without pretending atomicity",
      "objective": "Report each independently durable batch result without claiming the whole batch committed atomically.",
      "unit_id": "backend.course.foundations.18-what-they-may-do",
      "path": "/curriculum/backend?unit=backend.course.foundations.18-what-they-may-do",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "backend.lesson.syllabus-19-the-poison-message",
      "subject": "backend",
      "title": "Find a cross-row anomaly behind repeatable reads",
      "objective": "Recognize a cross-row write anomaly that repeatable individual reads alone do not prevent.",
      "unit_id": "backend.course.foundations.19-the-poison-message",
      "path": "/curriculum/backend?unit=backend.course.foundations.19-the-poison-message",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "backend.lesson.syllabus-20-reject-results-from-a-worker-whose-lease-was-replaced",
      "subject": "backend",
      "title": "Find the failed owner behind a chain of downstream symptoms",
      "objective": "Find the first failed fact owner in a dependency chain before treating downstream symptoms as independent causes.",
      "unit_id": "backend.course.foundations.20-reject-results-from-a-worker-whose-lease-was-replaced",
      "path": "/curriculum/backend?unit=backend.course.foundations.20-reject-results-from-a-worker-whose-lease-was-replaced",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "middleware.lesson.syllabus-01-a-contract-written-down",
      "subject": "middleware",
      "title": "Apply the declared decoder and extension-field policy",
      "objective": "Decode only a supported message envelope and apply its declared extension-field policy before downstream work.",
      "unit_id": "middleware.course.foundations.01-a-contract-written-down",
      "path": "/curriculum/middleware?unit=middleware.course.foundations.01-a-contract-written-down",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "middleware.lesson.syllabus-02-decode-only-a-supported-media-type-and-character-encod",
      "subject": "middleware",
      "title": "Preserve machine-readable failure identity through two services",
      "objective": "Preserve the public machine-readable failure identity across service hops without exporting private details.",
      "unit_id": "middleware.course.foundations.02-decode-only-a-supported-media-type-and-character-encod",
      "path": "/curriculum/middleware?unit=middleware.course.foundations.02-decode-only-a-supported-media-type-and-character-encod",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "middleware.lesson.syllabus-03-verify-the-exact-received-bytes-before-decoding-signed",
      "subject": "middleware",
      "title": "Preserve entity revision order across a partitioned stream",
      "objective": "Choose partition ownership that preserves each entity’s revision order across the delivered stream.",
      "unit_id": "middleware.course.foundations.03-verify-the-exact-received-bytes-before-decoding-signed",
      "path": "/curriculum/middleware?unit=middleware.course.foundations.03-verify-the-exact-received-bytes-before-decoding-signed",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "middleware.lesson.syllabus-04-commit-a-consumer-position-only-after-its-durable-work",
      "subject": "middleware",
      "title": "Extend visibility only for the delivery lease still owned",
      "objective": "Extend visibility only for the delivery lease currently owned, rejecting a replaced consumer’s token.",
      "unit_id": "middleware.course.foundations.04-commit-a-consumer-position-only-after-its-durable-work",
      "path": "/curriculum/middleware?unit=middleware.course.foundations.04-commit-a-consumer-position-only-after-its-durable-work",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "middleware.lesson.syllabus-05-a-gateway",
      "subject": "middleware",
      "title": "Apply a rate bucket to the real caller rather than a forged header",
      "objective": "Apply rate policy to the actual authenticated caller rather than a caller-supplied identity header.",
      "unit_id": "middleware.course.foundations.05-a-gateway",
      "path": "/curriculum/middleware?unit=middleware.course.foundations.05-a-gateway",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "middleware.lesson.syllabus-06-reject-an-oversized-request-before-copying-it-downstre",
      "subject": "middleware",
      "title": "Reject an oversized request before copying it through the chain",
      "objective": "Reject an oversized request before copying its body through the middleware chain.",
      "unit_id": "middleware.course.foundations.06-reject-an-oversized-request-before-copying-it-downstre",
      "path": "/curriculum/middleware?unit=middleware.course.foundations.06-reject-an-oversized-request-before-copying-it-downstre",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "middleware.lesson.syllabus-07-carry-an-absolute-deadline-without-extending-it-at-eac",
      "subject": "middleware",
      "title": "Hold an out-of-order revision until its predecessor is accepted",
      "objective": "Hold a bounded out-of-order revision until its required predecessor has actually been accepted.",
      "unit_id": "middleware.course.foundations.07-carry-an-absolute-deadline-without-extending-it-at-eac",
      "path": "/curriculum/middleware?unit=middleware.course.foundations.07-carry-an-absolute-deadline-without-extending-it-at-eac",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "middleware.lesson.syllabus-08-accept-forwarded-identity-only-from-a-trusted-ingress",
      "subject": "middleware",
      "title": "Trust forwarded caller fields only from the configured ingress",
      "objective": "Trust forwarded caller fields only when the actual peer is the configured ingress authority.",
      "unit_id": "middleware.course.foundations.08-accept-forwarded-identity-only-from-a-trusted-ingress",
      "path": "/curriculum/middleware?unit=middleware.course.foundations.08-accept-forwarded-identity-only-from-a-trusted-ingress",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "middleware.lesson.syllabus-09-map-internal-exceptions-to-the-stable-public-error-con",
      "subject": "middleware",
      "title": "Wrap downstream failure without swallowing owned cancellation",
      "objective": "Wrap a downstream failure without swallowing cancellation that still belongs to the caller.",
      "unit_id": "middleware.course.foundations.09-map-internal-exceptions-to-the-stable-public-error-con",
      "path": "/curriculum/middleware?unit=middleware.course.foundations.09-map-internal-exceptions-to-the-stable-public-error-con",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "middleware.lesson.syllabus-10-test-a-consumer-promise-against-independently-owned-fi",
      "subject": "middleware",
      "title": "Bound acquired deliveries before they overload worker memory",
      "objective": "Limit acquired deliveries according to downstream capacity instead of growing an unbounded worker backlog.",
      "unit_id": "middleware.course.foundations.10-test-a-consumer-promise-against-independently-owned-fi",
      "path": "/curriculum/middleware?unit=middleware.course.foundations.10-test-a-consumer-promise-against-independently-owned-fi",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "middleware.lesson.syllabus-11-protect-ordinary-work-from-permanent-priority-starvati",
      "subject": "middleware",
      "title": "Retry only a route whose operation contract permits replay",
      "objective": "Retry only routes whose effect contract permits replay and reconcile uncertain non-repeatable effects.",
      "unit_id": "middleware.course.foundations.11-protect-ordinary-work-from-permanent-priority-starvati",
      "path": "/curriculum/middleware?unit=middleware.course.foundations.11-protect-ordinary-work-from-permanent-priority-starvati",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "middleware.lesson.syllabus-12-testing-a-contract",
      "subject": "middleware",
      "title": "Build a replay-safe versioned transport adapter",
      "objective": "Execute the versioned transport adapter against durable identity, projection and cursor boundaries.",
      "unit_id": "middleware.course.foundations.12-testing-a-contract",
      "path": "/curriculum/middleware?unit=middleware.course.foundations.12-testing-a-contract",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "middleware.lesson.syllabus-13-commit-publication-intent-with-the-business-write",
      "subject": "middleware",
      "title": "Reject a changed command borrowing an accepted operation key",
      "objective": "Reject a changed command reusing an accepted scoped operation identity rather than applying it as new work.",
      "unit_id": "middleware.course.foundations.13-commit-publication-intent-with-the-business-write",
      "path": "/curriculum/middleware?unit=middleware.course.foundations.13-commit-publication-intent-with-the-business-write",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "middleware.lesson.syllabus-14-advance-a-projection-cursor-only-with-the-projected-up",
      "subject": "middleware",
      "title": "Retire sent intents without forgetting still-legal replays",
      "objective": "Retire publication intents only while retaining the acceptance evidence required by still-legal replays.",
      "unit_id": "middleware.course.foundations.14-advance-a-projection-cursor-only-with-the-projected-up",
      "path": "/curriculum/middleware?unit=middleware.course.foundations.14-advance-a-projection-cursor-only-with-the-projected-up",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "middleware.lesson.syllabus-15-rebuild-into-an-isolated-target-before-switching-reade",
      "subject": "middleware",
      "title": "Keep operation acceptance for every still-permitted retry",
      "objective": "Keep operation acceptance for the entire promised retry horizon instead of expiring its effect identity early.",
      "unit_id": "middleware.course.foundations.15-rebuild-into-an-isolated-target-before-switching-reade",
      "path": "/curriculum/middleware?unit=middleware.course.foundations.15-rebuild-into-an-isolated-target-before-switching-reade",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "middleware.lesson.syllabus-16-ordering",
      "subject": "middleware",
      "title": "Expire unused capacity without releasing fulfilled ownership",
      "objective": "Expire only tentative capacity and preserve ownership already transferred to a fulfilled order.",
      "unit_id": "middleware.course.foundations.16-ordering",
      "path": "/curriculum/middleware?unit=middleware.course.foundations.16-ordering",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "middleware.lesson.syllabus-17-shedding-load",
      "subject": "middleware",
      "title": "Restore the caller context after an interleaved asynchronous child",
      "objective": "Restore the caller’s logical context after nested work instead of retaining another operation’s context.",
      "unit_id": "middleware.course.foundations.17-shedding-load",
      "path": "/curriculum/middleware?unit=middleware.course.foundations.17-shedding-load",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "middleware.lesson.syllabus-18-release-request-context-after-normal-and-exceptional-c",
      "subject": "middleware",
      "title": "Propagate approved bounded context without exporting caller secrets",
      "objective": "Propagate only allowlisted bounded context fields and exclude caller secrets from diagnostic transport.",
      "unit_id": "middleware.course.foundations.18-release-request-context-after-normal-and-exceptional-c",
      "path": "/curriculum/middleware?unit=middleware.course.foundations.18-release-request-context-after-normal-and-exceptional-c",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "middleware.lesson.syllabus-19-detect-quarantined-work-separately-from-temporary-retr",
      "subject": "middleware",
      "title": "Alert on poison growth without confusing it with transient retries",
      "objective": "Alert on quarantine growth independently of transient retry backlog and preserve identity for a verified redrive.",
      "unit_id": "middleware.course.foundations.19-detect-quarantined-work-separately-from-temporary-retr",
      "path": "/curriculum/middleware?unit=middleware.course.foundations.19-detect-quarantined-work-separately-from-temporary-retr",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "middleware.lesson.syllabus-20-place-an-irreversible-action-behind-explicit-durable-a",
      "subject": "middleware",
      "title": "Measure overlapping attempts without inflating logical operation time",
      "objective": "Measure logical elapsed latency separately from aggregate and overlapping attempt work.",
      "unit_id": "middleware.course.foundations.20-place-an-irreversible-action-behind-explicit-durable-a",
      "path": "/curriculum/middleware?unit=middleware.course.foundations.20-place-an-irreversible-action-behind-explicit-durable-a",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "architecture.lesson.syllabus-01-a-projection-derives-from-one-owned-source",
      "subject": "architecture",
      "title": "Reject a stale entity transition at the fact owner",
      "objective": "Reject a stale entity transition at the authoritative fact owner before publishing derived views.",
      "unit_id": "architecture.course.foundations.01-a-projection-derives-from-one-owned-source",
      "path": "/curriculum/architecture?unit=architecture.course.foundations.01-a-projection-derives-from-one-owned-source",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "architecture.lesson.syllabus-02-commit-acceptance-identity-with-the-consuming-effect",
      "subject": "architecture",
      "title": "Choose reads from the promised freshness scope",
      "objective": "Select a read path that satisfies the caller’s promised freshness scope rather than choosing by convenience.",
      "unit_id": "architecture.course.foundations.02-commit-acceptance-identity-with-the-consuming-effect",
      "path": "/curriculum/architecture?unit=architecture.course.foundations.02-commit-acceptance-identity-with-the-consuming-effect",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "architecture.lesson.syllabus-03-coupling-and-cohesion",
      "subject": "architecture",
      "title": "Give inventory one writer and a separate derived read path",
      "objective": "Give inventory changes one authoritative writer and keep derived read ownership separate.",
      "unit_id": "architecture.course.foundations.03-coupling-and-cohesion",
      "path": "/curriculum/architecture?unit=architecture.course.foundations.03-coupling-and-cohesion",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "architecture.lesson.syllabus-04-group-behavior-that-changes-for-the-same-requirement",
      "subject": "architecture",
      "title": "Publish a versioned domain fact without exposing its storage layout",
      "objective": "Publish a versioned domain fact whose public contract does not expose private storage representation.",
      "unit_id": "architecture.course.foundations.04-group-behavior-that-changes-for-the-same-requirement",
      "path": "/curriculum/architecture?unit=architecture.course.foundations.04-group-behavior-that-changes-for-the-same-requirement",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "architecture.lesson.syllabus-05-keep-a-business-invariant-inside-its-atomic-owner",
      "subject": "architecture",
      "title": "Move policy ownership while keeping a legacy transport adapter compatible",
      "objective": "Move domain policy ownership while retaining a compatible legacy transport boundary.",
      "unit_id": "architecture.course.foundations.05-keep-a-business-invariant-inside-its-atomic-owner",
      "path": "/curriculum/architecture?unit=architecture.course.foundations.05-keep-a-business-invariant-inside-its-atomic-owner",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "architecture.lesson.syllabus-06-state-a-measurable-quality-requirement-with-stimulus-a",
      "subject": "architecture",
      "title": "Turn a quality claim into a measurable workload scenario",
      "objective": "Turn a qualitative requirement into a measurable workload, response and acceptance scenario.",
      "unit_id": "architecture.course.foundations.06-state-a-measurable-quality-requirement-with-stimulus-a",
      "path": "/curriculum/architecture?unit=architecture.course.foundations.06-state-a-measurable-quality-requirement-with-stimulus-a",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "architecture.lesson.syllabus-07-capture-existing-public-behavior-before-repairing-inte",
      "subject": "architecture",
      "title": "A decision record includes the rejected alternatives",
      "objective": "Record the chosen decision, rejected alternatives and consequences rather than preserving only the conclusion.",
      "unit_id": "architecture.course.foundations.07-capture-existing-public-behavior-before-repairing-inte",
      "path": "/curriculum/architecture?unit=architecture.course.foundations.07-capture-existing-public-behavior-before-repairing-inte",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "architecture.lesson.syllabus-08-separate-tentative-resource-ownership-from-durable-ful",
      "subject": "architecture",
      "title": "Compensate an owned reservation without releasing another operation’s stock",
      "objective": "Compensate only the reservation still owned by the failed operation, retaining another accepted owner’s stock.",
      "unit_id": "architecture.course.foundations.08-separate-tentative-resource-ownership-from-durable-ful",
      "path": "/curriculum/architecture?unit=architecture.course.foundations.08-separate-tentative-resource-ownership-from-durable-ful",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "architecture.lesson.syllabus-09-choose-a-rollout-guard-that-observes-the-changed-behav",
      "subject": "architecture",
      "title": "Invert a storage dependency without moving domain policy into the adapter",
      "objective": "Invert a storage dependency without transferring domain policy into its implementation adapter.",
      "unit_id": "architecture.course.foundations.09-choose-a-rollout-guard-that-observes-the-changed-behav",
      "path": "/curriculum/architecture?unit=architecture.course.foundations.09-choose-a-rollout-guard-that-observes-the-changed-behav",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "architecture.lesson.syllabus-10-place-validation-where-untrusted-data-enters-a-trust-z",
      "subject": "architecture",
      "title": "Give a renderer only the data and operations its task requires",
      "objective": "Give a renderer only the data and capabilities required by its current task.",
      "unit_id": "architecture.course.foundations.10-place-validation-where-untrusted-data-enters-a-trust-z",
      "path": "/curriculum/architecture?unit=architecture.course.foundations.10-place-validation-where-untrusted-data-enters-a-trust-z",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "architecture.lesson.syllabus-11-one-source-of-truth",
      "subject": "architecture",
      "title": "Keep publication intent and consumer acceptance with their own effects",
      "objective": "Keep publication intent and consumer acceptance in the durable boundary that owns their respective effects.",
      "unit_id": "architecture.course.foundations.11-one-source-of-truth",
      "path": "/curriculum/architecture?unit=architecture.course.foundations.11-one-source-of-truth",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "architecture.lesson.syllabus-12-apply-bounded-pressure-before-memory-grows-without-lim",
      "subject": "architecture",
      "title": "Admit only work that fits both capacity and time",
      "objective": "Admit work only when both its capacity demand and deadline fit the declared budget.",
      "unit_id": "architecture.course.foundations.12-apply-bounded-pressure-before-memory-grows-without-lim",
      "path": "/curriculum/architecture?unit=architecture.course.foundations.12-apply-bounded-pressure-before-memory-grows-without-lim",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "architecture.lesson.syllabus-13-keep-retry-amplification-below-an-explicit-recovery-bu",
      "subject": "architecture",
      "title": "Reserve capacity for a lost node without exceeding the shared database pool",
      "objective": "Reserve capacity for a failed node without exceeding the database pool shared by surviving nodes.",
      "unit_id": "architecture.course.foundations.13-keep-retry-amplification-below-an-explicit-recovery-bu",
      "path": "/curriculum/architecture?unit=architecture.course.foundations.13-keep-retry-amplification-below-an-explicit-recovery-bu",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "architecture.lesson.syllabus-14-every-retry-delay-consumes-the-same-budget",
      "subject": "architecture",
      "title": "Contain a failing notification dependency within its reserved pool",
      "objective": "Contain a failing notification dependency within its reserved pool so unrelated work remains admissible.",
      "unit_id": "architecture.course.foundations.14-every-retry-delay-consumes-the-same-budget",
      "path": "/curriculum/architecture?unit=architecture.course.foundations.14-every-retry-delay-consumes-the-same-budget",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "architecture.lesson.syllabus-15-understanding-what-is-there",
      "subject": "architecture",
      "title": "Move one live route without creating two writers",
      "objective": "Move a live route through one authoritative writer rather than temporarily creating two competing owners.",
      "unit_id": "architecture.course.foundations.15-understanding-what-is-there",
      "path": "/curriculum/architecture?unit=architecture.course.foundations.15-understanding-what-is-there",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "architecture.lesson.syllabus-16-choose-a-recovery-point-from-an-explicit-data-loss-bud",
      "subject": "architecture",
      "title": "Withdraw admission and verify a drain before releasing a measured bottleneck",
      "objective": "Withdraw new admission and verify the measured drain before releasing a bottleneck resource.",
      "unit_id": "architecture.course.foundations.16-choose-a-recovery-point-from-an-explicit-data-loss-bud",
      "path": "/curriculum/architecture?unit=architecture.course.foundations.16-choose-a-recovery-point-from-an-explicit-data-loss-bud",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "architecture.lesson.syllabus-17-pin-a-dependency-identity-before-accepting-an-artifact",
      "subject": "architecture",
      "title": "Enforce a transitive policy boundary while reviewing a plausible module graph",
      "objective": "Enforce the transitive dependency policy instead of checking only the immediate module edges.",
      "unit_id": "architecture.course.foundations.17-pin-a-dependency-identity-before-accepting-an-artifact",
      "path": "/curriculum/architecture?unit=architecture.course.foundations.17-pin-a-dependency-identity-before-accepting-an-artifact",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "architecture.lesson.syllabus-18-find-a-violated-invariant-in-a-plausible-proposed-topo",
      "subject": "architecture",
      "title": "Retire an old data representation only after compatible readers and references",
      "objective": "Retire an old representation only after compatible consumers and retained references no longer require it.",
      "unit_id": "architecture.course.foundations.18-find-a-violated-invariant-in-a-plausible-proposed-topo",
      "path": "/curriculum/architecture?unit=architecture.course.foundations.18-find-a-violated-invariant-in-a-plausible-proposed-topo",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "architecture.lesson.syllabus-19-changing-a-decision-you-already-shipped",
      "subject": "architecture",
      "title": "Restore a failed authority before rebuilding its derived consumers",
      "objective": "Restore authoritative facts before rebuilding consumers whose state is derived from them.",
      "unit_id": "architecture.course.foundations.19-changing-a-decision-you-already-shipped",
      "path": "/curriculum/architecture?unit=architecture.course.foundations.19-changing-a-decision-you-already-shipped",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "architecture.lesson.syllabus-20-route-failover-within-the-declared-consistency-boundar",
      "subject": "architecture",
      "title": "Resolve competing quality requirements with an explicit cost model",
      "objective": "Compare competing quality requirements with an explicit workload and cost model.",
      "unit_id": "architecture.course.foundations.20-route-failover-within-the-declared-consistency-boundar",
      "path": "/curriculum/architecture?unit=architecture.course.foundations.20-route-failover-within-the-declared-consistency-boundar",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "llm-rag.lesson.tokens",
      "subject": "llm-rag",
      "title": "Turn text into token IDs",
      "objective": "Map text to a fixed vocabulary and preserve unknown tokens explicitly.",
      "unit_id": "llm-rag.course.foundations.01-tokens",
      "path": "/curriculum/llm-rag?unit=llm-rag.course.foundations.01-tokens",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "llm-rag.lesson.next-token",
      "subject": "llm-rag",
      "title": "Train a tiny next-token model",
      "objective": "Learn adjacent-token counts from a corpus without crossing document boundaries.",
      "unit_id": "llm-rag.course.foundations.02-next-token",
      "path": "/curriculum/llm-rag?unit=llm-rag.course.foundations.02-next-token",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "llm-rag.lesson.probabilities",
      "subject": "llm-rag",
      "title": "Normalize logits safely",
      "objective": "Use stable softmax and temperature without confusing confidence with correctness.",
      "unit_id": "llm-rag.course.foundations.03-probabilities",
      "path": "/curriculum/llm-rag?unit=llm-rag.course.foundations.03-probabilities",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "llm-rag.lesson.loss",
      "subject": "llm-rag",
      "title": "Measure next-token prediction loss",
      "objective": "Compute mean negative log-likelihood only over assessed target positions.",
      "unit_id": "llm-rag.course.foundations.04-loss",
      "path": "/curriculum/llm-rag?unit=llm-rag.course.foundations.04-loss",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "llm-rag.lesson.gradient",
      "subject": "llm-rag",
      "title": "Update model parameters from error",
      "objective": "Perform one gradient step and check whether a small training objective improves.",
      "unit_id": "llm-rag.course.foundations.05-gradient",
      "path": "/curriculum/llm-rag?unit=llm-rag.course.foundations.05-gradient",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "llm-rag.lesson.attention",
      "subject": "llm-rag",
      "title": "Combine context with attention weights",
      "objective": "Build an attention-weighted value vector and enforce causal visibility.",
      "unit_id": "llm-rag.course.foundations.06-attention",
      "path": "/curriculum/llm-rag?unit=llm-rag.course.foundations.06-attention",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "llm-rag.lesson.data-splits",
      "subject": "llm-rag",
      "title": "Separate training from evaluation",
      "objective": "Keep related documents in one split and reject contaminated evaluations.",
      "unit_id": "llm-rag.course.foundations.07-data-splits",
      "path": "/curriculum/llm-rag?unit=llm-rag.course.foundations.07-data-splits",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "llm-rag.lesson.fine-tuning",
      "subject": "llm-rag",
      "title": "Prepare supervised fine-tuning examples",
      "objective": "Select valid instruction-response pairs and build an explicit completion-loss mask.",
      "unit_id": "llm-rag.course.foundations.08-fine-tuning",
      "path": "/curriculum/llm-rag?unit=llm-rag.course.foundations.08-fine-tuning",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "llm-rag.lesson.chunking",
      "subject": "llm-rag",
      "title": "Chunk documents with source provenance",
      "objective": "Create bounded overlapping chunks while keeping source identity and offsets.",
      "unit_id": "llm-rag.course.foundations.09-chunking",
      "path": "/curriculum/llm-rag?unit=llm-rag.course.foundations.09-chunking",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "llm-rag.lesson.similarity",
      "subject": "llm-rag",
      "title": "Compare embeddings correctly",
      "objective": "Use cosine similarity without confusing vector length with relevance.",
      "unit_id": "llm-rag.course.foundations.10-similarity",
      "path": "/curriculum/llm-rag?unit=llm-rag.course.foundations.10-similarity",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "llm-rag.lesson.ranking",
      "subject": "llm-rag",
      "title": "Rank retrieval candidates with stable ties",
      "objective": "Choose top-k unique retrieval results and measure whether relevant sources were found.",
      "unit_id": "llm-rag.course.foundations.11-ranking",
      "path": "/curriculum/llm-rag?unit=llm-rag.course.foundations.11-ranking",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "llm-rag.lesson.retrieval-access",
      "subject": "llm-rag",
      "title": "Filter evidence before it reaches the model",
      "objective": "Prevent cross-tenant retrieval and preserve source revision boundaries.",
      "unit_id": "llm-rag.course.foundations.12-retrieval-access",
      "path": "/curriculum/llm-rag?unit=llm-rag.course.foundations.12-retrieval-access",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "llm-rag.lesson.context-budget",
      "subject": "llm-rag",
      "title": "Fit evidence into a bounded context",
      "objective": "Reserve output space and select complete chunks within a token budget.",
      "unit_id": "llm-rag.course.foundations.13-context-budget",
      "path": "/curriculum/llm-rag?unit=llm-rag.course.foundations.13-context-budget",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "llm-rag.lesson.grounding",
      "subject": "llm-rag",
      "title": "Check answer provenance and abstention",
      "objective": "Validate citation membership and abstain when supplied evidence is insufficient.",
      "unit_id": "llm-rag.course.foundations.14-grounding",
      "path": "/curriculum/llm-rag?unit=llm-rag.course.foundations.14-grounding",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "llm-rag.lesson.build-a-pipeline",
      "subject": "llm-rag",
      "title": "Assemble a small AI and retrieval pipeline",
      "objective": "Connect learned next-token counts to inference, and authorized retrieval to a grounded model request.",
      "unit_id": "llm-rag.course.foundations.15-build-a-pipeline",
      "path": "/curriculum/llm-rag?unit=llm-rag.course.foundations.15-build-a-pipeline",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "llm-rag.lesson.optimization-runs",
      "subject": "llm-rag",
      "title": "Control optimization across microbatches",
      "objective": "Combine gradients by example count and schedule learning rates with explicit warmup and decay boundaries.",
      "unit_id": "llm-rag.course.foundations.16-optimization-runs",
      "path": "/curriculum/llm-rag?unit=llm-rag.course.foundations.16-optimization-runs",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "llm-rag.lesson.causal-transformer",
      "subject": "llm-rag",
      "title": "Build causal transformer mechanics",
      "objective": "Construct causal visibility and normalize attention only over tokens available at a query position.",
      "unit_id": "llm-rag.course.foundations.17-causal-transformer",
      "path": "/curriculum/llm-rag?unit=llm-rag.course.foundations.17-causal-transformer",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "llm-rag.lesson.model-evaluation",
      "subject": "llm-rag",
      "title": "Evaluate models across meaningful slices",
      "objective": "Measure token prediction quality and expose subgroup failures that a single aggregate can hide.",
      "unit_id": "llm-rag.course.foundations.18-model-evaluation",
      "path": "/curriculum/llm-rag?unit=llm-rag.course.foundations.18-model-evaluation",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "llm-rag.lesson.rag-evaluation",
      "subject": "llm-rag",
      "title": "Evaluate retrieval before generation",
      "objective": "Measure coverage and first-hit rank on frozen relevance judgments before blaming the generator.",
      "unit_id": "llm-rag.course.foundations.19-rag-evaluation",
      "path": "/curriculum/llm-rag?unit=llm-rag.course.foundations.19-rag-evaluation",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "llm-rag.lesson.production-lifecycle",
      "subject": "llm-rag",
      "title": "Release and monitor an AI system",
      "objective": "Compute a release decision from supplied quality, latency and safety metrics, then measure total-variation distance between supplied distributions. Use these bounded checks as preparation for deployment monitoring, not proof that monitoring ran.",
      "unit_id": "llm-rag.course.foundations.20-production-lifecycle",
      "path": "/curriculum/llm-rag?unit=llm-rag.course.foundations.20-production-lifecycle",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "agentic.lesson.task-brief",
      "subject": "agentic",
      "title": "Give an AI a verifiable programming task",
      "objective": "Separate the requested behavior, scope, and acceptance evidence in a coding brief.",
      "unit_id": "agentic.course.foundations.01-task-brief",
      "path": "/curriculum/agentic?unit=agentic.course.foundations.01-task-brief",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "agentic.lesson.context",
      "subject": "agentic",
      "title": "Supply relevant context without secrets",
      "objective": "Choose task-relevant repository context while keeping sensitive files out of requests.",
      "unit_id": "agentic.course.foundations.02-context",
      "path": "/curriculum/agentic?unit=agentic.course.foundations.02-context",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "agentic.lesson.acceptance",
      "subject": "agentic",
      "title": "Write acceptance tests before trusting a patch",
      "objective": "Turn boundary requirements into executable checks and keep missing evidence visible.",
      "unit_id": "agentic.course.foundations.03-acceptance",
      "path": "/curriculum/agentic?unit=agentic.course.foundations.03-acceptance",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "agentic.lesson.patch-scope",
      "subject": "agentic",
      "title": "Inspect proposed changes against scope",
      "objective": "Detect unapproved file changes and separate edits from deletion intent.",
      "unit_id": "agentic.course.foundations.04-patch-scope",
      "path": "/curriculum/agentic?unit=agentic.course.foundations.04-patch-scope",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "agentic.lesson.regression",
      "subject": "agentic",
      "title": "Use a failing test to guide an AI repair",
      "objective": "Demonstrate a defect before the patch and verify the same contract afterward.",
      "unit_id": "agentic.course.foundations.05-regression",
      "path": "/curriculum/agentic?unit=agentic.course.foundations.05-regression",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "agentic.lesson.tool-contracts",
      "subject": "agentic",
      "title": "Validate an AI’s tool requests",
      "objective": "Restrict tool names and validate arguments before executing a model proposal.",
      "unit_id": "agentic.course.foundations.06-tool-contracts",
      "path": "/curriculum/agentic?unit=agentic.course.foundations.06-tool-contracts",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "agentic.lesson.approval",
      "subject": "agentic",
      "title": "Keep consequential actions behind explicit approval",
      "objective": "Match an approval to its exact action and distinguish review from execution permission.",
      "unit_id": "agentic.course.foundations.07-approval",
      "path": "/curriculum/agentic?unit=agentic.course.foundations.07-approval",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "agentic.lesson.bounded-loop",
      "subject": "agentic",
      "title": "Control an assistant’s repair loop",
      "objective": "Stop on success or exhaustion and surface failure rather than retrying indefinitely.",
      "unit_id": "agentic.course.foundations.08-bounded-loop",
      "path": "/curriculum/agentic?unit=agentic.course.foundations.08-bounded-loop",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "agentic.lesson.cost-and-traces",
      "subject": "agentic",
      "title": "Measure cost and inspect the action trace",
      "objective": "Account for token cost and preserve failures in a readable execution history.",
      "unit_id": "agentic.course.foundations.09-cost-and-traces",
      "path": "/curriculum/agentic?unit=agentic.course.foundations.09-cost-and-traces",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "agentic.lesson.completion-review",
      "subject": "agentic",
      "title": "Accept results using evidence, not confidence",
      "objective": "Require current checks and review findings before accepting an AI-generated change.",
      "unit_id": "agentic.course.foundations.10-completion-review",
      "path": "/curriculum/agentic?unit=agentic.course.foundations.10-completion-review",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "agentic.lesson.task-graphs",
      "subject": "agentic",
      "title": "Turn a large request into a dependency graph",
      "objective": "Decompose a programming objective into independently verifiable tasks whose dependencies and acceptance evidence are explicit.",
      "unit_id": "agentic.course.foundations.11-task-graphs",
      "path": "/curriculum/agentic?unit=agentic.course.foundations.11-task-graphs",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "agentic.lesson.model-routing",
      "subject": "agentic",
      "title": "Route work to the least costly capable model",
      "objective": "Choose a model from explicit capability, context, privacy, latency, and cost constraints instead of using one model for every step.",
      "unit_id": "agentic.course.foundations.12-model-routing",
      "path": "/curriculum/agentic?unit=agentic.course.foundations.12-model-routing",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "agentic.lesson.durable-state",
      "subject": "agentic",
      "title": "Checkpoint agent state for safe resume",
      "objective": "Persist the minimum trusted state needed to resume a workflow without replaying completed side effects.",
      "unit_id": "agentic.course.foundations.13-durable-state",
      "path": "/curriculum/agentic?unit=agentic.course.foundations.13-durable-state",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "agentic.lesson.multi-agent-handoffs",
      "subject": "agentic",
      "title": "Delegate work with explicit handoff contracts",
      "objective": "Assign bounded work to specialized agents and merge their findings without losing provenance or ownership.",
      "unit_id": "agentic.course.foundations.14-multi-agent-handoffs",
      "path": "/curriculum/agentic?unit=agentic.course.foundations.14-multi-agent-handoffs",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "agentic.lesson.parallel-execution",
      "subject": "agentic",
      "title": "Run agent work concurrently without corrupting state",
      "objective": "Control concurrency through resource ownership, deterministic joins, cancellation, and bounded fan-out.",
      "unit_id": "agentic.course.foundations.15-parallel-execution",
      "path": "/curriculum/agentic?unit=agentic.course.foundations.15-parallel-execution",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "agentic.lesson.untrusted-instructions",
      "subject": "agentic",
      "title": "Keep untrusted content out of the control plane",
      "objective": "Separate trusted instructions from repository, web, email, and retrieved content that may attempt to redirect an agent.",
      "unit_id": "agentic.course.foundations.16-untrusted-instructions",
      "path": "/curriculum/agentic?unit=agentic.course.foundations.16-untrusted-instructions",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "agentic.lesson.agent-evaluation",
      "subject": "agentic",
      "title": "Evaluate agent behavior by task and failure slice",
      "objective": "Build reproducible agent evaluations that measure task success, tool behavior, safety boundaries, and regressions across meaningful slices.",
      "unit_id": "agentic.course.foundations.17-agent-evaluation",
      "path": "/curriculum/agentic?unit=agentic.course.foundations.17-agent-evaluation",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "agentic.lesson.retries-and-idempotency",
      "subject": "agentic",
      "title": "Design retries that do not duplicate consequences",
      "objective": "Classify failures, apply bounded backoff, and make retried tool actions idempotent or explicitly reconciled.",
      "unit_id": "agentic.course.foundations.18-retries-and-idempotency",
      "path": "/curriculum/agentic?unit=agentic.course.foundations.18-retries-and-idempotency",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "agentic.lesson.observability",
      "subject": "agentic",
      "title": "Operate agent workflows from structured traces",
      "objective": "Instrument agent runs with correlated spans, decisions, costs, artifacts, and redacted failures that support diagnosis without exposing secrets.",
      "unit_id": "agentic.course.foundations.19-observability",
      "path": "/curriculum/agentic?unit=agentic.course.foundations.19-observability",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "agentic.lesson.production-capstone",
      "subject": "agentic",
      "title": "Ship an accountable agent-assisted change",
      "objective": "Evaluate supplied version-linked release records and choose the first invalid required workflow stage. Then use the connected repository workspace to collect actual file, test, Git and reload evidence; the selectors alone do not execute a production workflow.",
      "unit_id": "agentic.course.foundations.20-production-capstone",
      "path": "/curriculum/agentic?unit=agentic.course.foundations.20-production-capstone",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "node.lesson.syllabus-01-a-small-runtime-boundary",
      "subject": "node",
      "title": "Read a filename extension with Node",
      "objective": "Use the supplied POSIX path API to classify a final filename suffix without opening a file or confusing dotfiles with extensions.",
      "unit_id": "node.course.foundations.01-a-small-runtime-boundary",
      "path": "/curriculum/node?unit=node.course.foundations.01-a-small-runtime-boundary",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "node.lesson.syllabus-02-preserve-caller-input",
      "subject": "node",
      "title": "Add operation context without replacing the original cause",
      "objective": "Await an operation inside its context boundary and retain the exact original rejection as the wrapped error’s cause.",
      "unit_id": "node.course.foundations.02-preserve-caller-input",
      "path": "/curriculum/node?unit=node.course.foundations.02-preserve-caller-input",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "node.lesson.syllabus-03-successful-identity",
      "subject": "node",
      "title": "The environment is a map of strings, and everything else is you",
      "objective": "Parse string-valued settings explicitly and serialize diagnostic fields without losing reserved level or Error.message.",
      "unit_id": "node.course.foundations.03-successful-identity",
      "path": "/curriculum/node?unit=node.course.foundations.03-successful-identity",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "node.lesson.syllabus-04-microtasks-are-not-an-i-o-turn",
      "subject": "node",
      "title": "Read valid UTF-8 and close the file on either outcome",
      "objective": "Decode a complete file as strict UTF-8 and close its acquired handle after either successful reading or failure.",
      "unit_id": "node.course.foundations.04-microtasks-are-not-an-i-o-turn",
      "path": "/curriculum/node?unit=node.course.foundations.04-microtasks-are-not-an-i-o-turn",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "node.lesson.syllabus-05-error-code-policy",
      "subject": "node",
      "title": "Dispose of a temporary workspace after success and failure",
      "objective": "Acquire an operation-owned temporary directory and remove it after awaited work settles without replacing that work’s result.",
      "unit_id": "node.course.foundations.05-error-code-policy",
      "path": "/curriculum/node?unit=node.course.foundations.05-error-code-policy",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "node.lesson.syllabus-06-empty-completion",
      "subject": "node",
      "title": "Wait for the whole pipeline before reporting success",
      "objective": "Await the complete stream pipeline so downstream failure cannot be reported as successful upstream completion.",
      "unit_id": "node.course.foundations.06-empty-completion",
      "path": "/curriculum/node?unit=node.course.foundations.06-empty-completion",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "node.lesson.syllabus-07-allow-metadata",
      "subject": "node",
      "title": "Keep HTTP rejection separate from a transport failure",
      "objective": "Distinguish a received non-success HTTP response from a transport rejection and preserve the corresponding diagnostic cause.",
      "unit_id": "node.course.foundations.07-allow-metadata",
      "path": "/curriculum/node?unit=node.course.foundations.07-allow-metadata",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "node.lesson.syllabus-08-real-pending-cancellation",
      "subject": "node",
      "title": "Dispose only the event subscriptions your scope owns",
      "objective": "Dispose only the listeners acquired by this subscription scope, retaining external listeners and independent registrations.",
      "unit_id": "node.course.foundations.08-real-pending-cancellation",
      "path": "/curriculum/node?unit=node.course.foundations.08-real-pending-cancellation",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "node.lesson.syllabus-09-separate-channels",
      "subject": "node",
      "title": "Move CPU computation into a real worker thread",
      "objective": "Execute CPU work in an actual worker thread and observe its result, failure and termination rather than blocking the caller.",
      "unit_id": "node.course.foundations.09-separate-channels",
      "path": "/curriculum/node?unit=node.course.foundations.09-separate-channels",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "node.lesson.syllabus-10-keep-exclusive-create-cleanup-within-its-ownership",
      "subject": "node",
      "title": "Hash original bytes without collecting the whole body",
      "objective": "Hash original input bytes incrementally without collecting the complete stream or decoding its binary content as text.",
      "unit_id": "node.course.foundations.10-keep-exclusive-create-cleanup-within-its-ownership",
      "path": "/curriculum/node?unit=node.course.foundations.10-keep-exclusive-create-cleanup-within-its-ownership",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "node.lesson.syllabus-11-the-rejection-nobody-caught",
      "subject": "node",
      "title": "The difference between 404 and 405",
      "objective": "Separate an unknown route from an unsupported method and return the declared status and allowed-method information.",
      "unit_id": "node.course.foundations.11-the-rejection-nobody-caught",
      "path": "/curriculum/node?unit=node.course.foundations.11-the-rejection-nobody-caught",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "node.lesson.syllabus-12-calling-something-else",
      "subject": "node",
      "title": "Publish a complete JSON file or preserve the old file",
      "objective": "Prepare and close a complete JSON file before publishing it, retaining the old destination and settling owned staging on failure.",
      "unit_id": "node.course.foundations.12-calling-something-else",
      "path": "/curriculum/node?unit=node.course.foundations.12-calling-something-else",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "node.lesson.syllabus-13-chunks-are-not-characters",
      "subject": "node",
      "title": "Frame Unicode lines across arbitrary byte chunks",
      "objective": "Decode incremental UTF-8 chunks before framing lines, retaining multibyte characters and the final unterminated line.",
      "unit_id": "node.course.foundations.13-chunks-are-not-characters",
      "path": "/curriculum/node?unit=node.course.foundations.13-chunks-are-not-characters",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "node.lesson.syllabus-14-completion-ownership",
      "subject": "node",
      "title": "Wait when a writable asks its producer to pause",
      "objective": "Pause production when write returns false and resume only after the writable’s drain or failure outcome.",
      "unit_id": "node.course.foundations.14-completion-ownership",
      "path": "/curriculum/node?unit=node.course.foundations.14-completion-ownership",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "node.lesson.syllabus-15-validation-before-effects",
      "subject": "node",
      "title": "Retry only declared transient errors within a finite budget",
      "objective": "Retry only classified transient failures within the declared attempt budget, preserving permanent and exhausted errors.",
      "unit_id": "node.course.foundations.15-validation-before-effects",
      "path": "/curriculum/node?unit=node.course.foundations.15-validation-before-effects",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "node.lesson.syllabus-16-pause-ownership",
      "subject": "node",
      "title": "Stop admitting new work and wait for accepted work",
      "objective": "Stop admitting new work and await every already accepted operation before reporting a completed shutdown.",
      "unit_id": "node.course.foundations.16-pause-ownership",
      "path": "/curriculum/node?unit=node.course.foundations.16-pause-ownership",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "node.lesson.syllabus-17-worker-ownership",
      "subject": "node",
      "title": "Terminate a worker when its owning operation is canceled",
      "objective": "Terminate the worker owned by a canceled operation while preserving caller cancellation and settling completion once.",
      "unit_id": "node.course.foundations.17-worker-ownership",
      "path": "/curriculum/node?unit=node.course.foundations.17-worker-ownership",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "node.lesson.syllabus-18-expired-state",
      "subject": "node",
      "title": "Apply and prune a rate window using a controlled clock",
      "objective": "Use an injected clock to prune a sliding admission window and evaluate its exact limit boundary without real-time sleeps.",
      "unit_id": "node.course.foundations.18-expired-state",
      "path": "/curriculum/node?unit=node.course.foundations.18-expired-state",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "node.lesson.syllabus-19-join-a-spawned-child-with-both-output-streams",
      "subject": "node",
      "title": "Append committed records and recover only a torn final fragment",
      "objective": "Append complete committed records and recover only a torn final fragment, rejecting corruption in earlier retained history.",
      "unit_id": "node.course.foundations.19-join-a-spawned-child-with-both-output-streams",
      "path": "/curriculum/node?unit=node.course.foundations.19-join-a-spawned-child-with-both-output-streams",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "node.lesson.syllabus-20-torn-final-append",
      "subject": "node",
      "title": "Serve a local file after validating its decoded path and real target",
      "objective": "Validate decoded paths and actual filesystem targets before serving bytes, keeping links from escaping the configured root.",
      "unit_id": "node.course.foundations.20-torn-final-append",
      "path": "/curriculum/node?unit=node.course.foundations.20-torn-final-append",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "go.lesson.values-and-errors",
      "subject": "go",
      "title": "Keep exact values and inspectable errors",
      "objective": "Validate exact value domains before evaluation, preserve zero values where valid, and keep wrapped Go error identity useful without accepting a typed nil.",
      "unit_id": "go.course.foundations.01-values-and-errors",
      "path": "/curriculum/go?unit=go.course.foundations.01-values-and-errors",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "go.lesson.text-and-record-boundaries",
      "subject": "go",
      "title": "Separate bytes, runes, captures and record endings",
      "objective": "Process UTF-8 and borrowed record slices without confusing storage offsets, code points, capture participation or delimiter bytes.",
      "unit_id": "go.course.foundations.02-text-and-record-boundaries",
      "path": "/curriculum/go?unit=go.course.foundations.02-text-and-record-boundaries",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "go.lesson.collections-and-invariants",
      "subject": "go",
      "title": "Own the storage behind a Go collection",
      "objective": "Preserve zero-value usability, absence, encounter order and caller ownership across slices, maps and generic collection operations.",
      "unit_id": "go.course.foundations.03-collections-and-invariants",
      "path": "/curriculum/go?unit=go.course.foundations.03-collections-and-invariants",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "go.lesson.files-and-streams",
      "subject": "go",
      "title": "Own the opened object and publish only complete files",
      "objective": "Confine file acquisition to an owned directory handle, settle every opened resource, and replace output only after complete prepared-file publication.",
      "unit_id": "go.course.foundations.04-files-and-streams",
      "path": "/curriculum/go?unit=go.course.foundations.04-files-and-streams",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "go.lesson.generic-api-boundaries",
      "subject": "go",
      "title": "Preserve types behind narrow generic APIs",
      "objective": "Use type parameters, underlying-type constraints and caller-owned interfaces without erasing concrete results or admitting invalid map keys.",
      "unit_id": "go.course.foundations.05-generic-api-boundaries",
      "path": "/curriculum/go?unit=go.course.foundations.05-generic-api-boundaries",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "go.lesson.bounded-reader-writer-contracts",
      "subject": "go",
      "title": "Account for every byte before interpreting I/O status",
      "objective": "Honor Go reader and writer progress, hard byte limits and terminal errors without discarding accepted data or presenting a partial stream as complete.",
      "unit_id": "go.course.foundations.06-bounded-reader-writer-contracts",
      "path": "/curriculum/go?unit=go.course.foundations.06-bounded-reader-writer-contracts",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "go.lesson.strict-serialization",
      "subject": "go",
      "title": "Accept one unambiguous serialized document",
      "objective": "Preserve exact number spelling and struct visibility while rejecting duplicate fields, invalid UTF-8, trailing documents and ambiguous exported schemas.",
      "unit_id": "go.course.foundations.07-strict-serialization",
      "path": "/curriculum/go?unit=go.course.foundations.07-strict-serialization",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "go.lesson.stable-collection-algorithms",
      "subject": "go",
      "title": "Make ordering and interval policy explicit",
      "objective": "Transform caller-owned collections without aliasing or reordering surprises, and encode tie and interval semantics directly in comparisons.",
      "unit_id": "go.course.foundations.08-stable-collection-algorithms",
      "path": "/curriculum/go?unit=go.course.foundations.08-stable-collection-algorithms",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "go.lesson.configuration-presence",
      "subject": "go",
      "title": "Resolve presence before applying defaults",
      "objective": "Keep absent, present-empty, explicit-zero and repeated configuration states distinct across maps, environment input and command arguments.",
      "unit_id": "go.course.foundations.09-configuration-presence",
      "path": "/curriculum/go?unit=go.course.foundations.09-configuration-presence",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "go.lesson.filesystem-inventory",
      "subject": "go",
      "title": "Classify directory entries without following them",
      "objective": "Build deterministic file inventories from acquired metadata, keep each resource lifetime short and never publish a partial walk as complete.",
      "unit_id": "go.course.foundations.10-filesystem-inventory",
      "path": "/curriculum/go?unit=go.course.foundations.10-filesystem-inventory",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "go.lesson.web-text-boundaries",
      "subject": "go",
      "title": "Keep web text in its declared grammar and trust domain",
      "objective": "Preserve repeated query values, escape untrusted markup, normalize timestamps deliberately and retain the difference between missing and empty captures.",
      "unit_id": "go.course.foundations.11-web-text-boundaries",
      "path": "/curriculum/go?unit=go.course.foundations.11-web-text-boundaries",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "go.lesson.concurrent-owners",
      "subject": "go",
      "title": "Cancel blocked edges and join every goroutine",
      "objective": "Bound admitted work, make both receives and sends cancellation-aware, retain the triggering error, and wait for every started goroutine before returning.",
      "unit_id": "go.course.foundations.12-concurrent-owners",
      "path": "/curriculum/go?unit=go.course.foundations.12-concurrent-owners",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "go.lesson.http-service-state",
      "subject": "go",
      "title": "Keep protocol decisions outside committed service state",
      "objective": "Enforce HTTP method, media, size and decoding boundaries before service effects, then make repeated command identity preserve one accepted effect.",
      "unit_id": "go.course.foundations.13-http-service-state",
      "path": "/curriculum/go?unit=go.course.foundations.13-http-service-state",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "go.lesson.measured-bounded-computation",
      "subject": "go",
      "title": "Prove both the answer and the work bound",
      "objective": "Guard exact numeric boundaries and implement search or dynamic programming with an instrumented amount of work rather than a plausible result alone.",
      "unit_id": "go.course.foundations.14-measured-bounded-computation",
      "path": "/curriculum/go?unit=go.course.foundations.14-measured-bounded-computation",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "go.lesson.initialization-and-cache-publication",
      "subject": "go",
      "title": "Publish initialized and cached state only after its owner commits",
      "objective": "Make one-time results, including failure, visible consistently and prevent a cache from advertising work its durable owner rejected.",
      "unit_id": "go.course.foundations.15-initialization-and-cache-publication",
      "path": "/curriculum/go?unit=go.course.foundations.15-initialization-and-cache-publication",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "go.lesson.controlled-retry-and-rate",
      "subject": "go",
      "title": "Inject time and stop at the declared budget",
      "objective": "Classify retryable failure, count attempts exactly, make waiting cancelable and test rate windows with an explicit clock instead of sleeps.",
      "unit_id": "go.course.foundations.16-controlled-retry-and-rate",
      "path": "/curriculum/go?unit=go.course.foundations.16-controlled-retry-and-rate",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "go.lesson.tcp-framing-and-deadlines",
      "subject": "go",
      "title": "Spend one network deadline across acquisition and I/O",
      "objective": "Frame portable network data, complete short transfers and keep address identity, socket ownership and one absolute deadline explicit.",
      "unit_id": "go.course.foundations.17-tcp-framing-and-deadlines",
      "path": "/curriculum/go?unit=go.course.foundations.17-tcp-framing-and-deadlines",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "go.lesson.encoding-and-integrity",
      "subject": "go",
      "title": "Verify the entire encoded object",
      "objective": "Distinguish canonical encoding, bounded expansion, corruption detection and authentication, and return no partial plaintext after rejection.",
      "unit_id": "go.course.foundations.18-encoding-and-integrity",
      "path": "/curriculum/go?unit=go.course.foundations.18-encoding-and-integrity",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "go.lesson.cleanup-and-compensation",
      "subject": "go",
      "title": "Settle every acquired effect without hiding failure",
      "objective": "Use defer, joined errors and reverse compensation so owned cleanup runs exactly once on success and failure while every error identity remains inspectable.",
      "unit_id": "go.course.foundations.19-cleanup-and-compensation",
      "path": "/curriculum/go?unit=go.course.foundations.19-cleanup-and-compensation",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "go.lesson.race-checked-transfer",
      "subject": "go",
      "title": "Make shared-state evidence match the work performed",
      "objective": "Perform real concurrent updates through one synchronization rule, publish detached snapshots, and make invalid admission produce no callback or partial state.",
      "unit_id": "go.course.foundations.20-race-checked-transfer",
      "path": "/curriculum/go?unit=go.course.foundations.20-race-checked-transfer",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "rust.lesson.ownership-and-views",
      "subject": "rust",
      "title": "Return a view only while its owner lives",
      "objective": "Choose moves, borrows and deliberate clones so every returned view has a valid owner and independent data is copied only where the contract needs it.",
      "unit_id": "rust.course.foundations.01-ownership-and-views",
      "path": "/curriculum/rust?unit=rust.course.foundations.01-ownership-and-views",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "rust.lesson.unicode-and-cow",
      "subject": "rust",
      "title": "Borrow valid text and own only the repair",
      "objective": "Choose byte, scalar-value and ownership units explicitly, returning Cow only when the unchanged path can truly borrow caller storage.",
      "unit_id": "rust.course.foundations.02-unicode-and-cow",
      "path": "/curriculum/rust?unit=rust.course.foundations.02-unicode-and-cow",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "rust.lesson.typed-failure",
      "subject": "rust",
      "title": "Keep syntax, range and framing failures distinct",
      "objective": "Parse exact data into Result values whose variants preserve whether the input grammar, numeric range or binary framing failed.",
      "unit_id": "rust.course.foundations.03-typed-failure",
      "path": "/curriculum/rust?unit=rust.course.foundations.03-typed-failure",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "rust.lesson.bounded-collections",
      "subject": "rust",
      "title": "Keep collection changes private until they succeed",
      "objective": "Move non-Clone values through suitable collections and publish a stable transformation only after every fallible decision succeeds.",
      "unit_id": "rust.course.foundations.04-bounded-collections",
      "path": "/curriculum/rust?unit=rust.course.foundations.04-bounded-collections",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "rust.lesson.disjoint-mutation",
      "subject": "rust",
      "title": "Prove mutable regions do not overlap",
      "objective": "Move owned buffers without cloning and derive simultaneous mutable views only through a boundary that proves the regions are disjoint.",
      "unit_id": "rust.course.foundations.05-disjoint-mutation",
      "path": "/curriculum/rust?unit=rust.course.foundations.05-disjoint-mutation",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "rust.lesson.validated-domain-types",
      "subject": "rust",
      "title": "Make invalid numeric state unrepresentable",
      "objective": "Validate grammar and range before narrowing into private domain types, preserving exact money and endpoint values without float conversion.",
      "unit_id": "rust.course.foundations.06-validated-domain-types",
      "path": "/curriculum/rust?unit=rust.course.foundations.06-validated-domain-types",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "rust.lesson.binary-frame-types",
      "subject": "rust",
      "title": "Validate a frame before exposing a typed view",
      "objective": "Decode declared byte order and bounded lengths before slicing, and convert runtime records to exact owned array sizes without truncation or padding.",
      "unit_id": "rust.course.foundations.07-binary-frame-types",
      "path": "/curriculum/rust?unit=rust.course.foundations.07-binary-frame-types",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "rust.lesson.complete-stream-io",
      "subject": "rust",
      "title": "Complete borrowed stream operations without inventing EOF",
      "objective": "Continue across short successful reads and writes, preserve underlying failure kinds and advance buffered input only by bytes actually consumed.",
      "unit_id": "rust.course.foundations.08-complete-stream-io",
      "path": "/curriculum/rust?unit=rust.course.foundations.08-complete-stream-io",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "rust.lesson.portable-paths-and-walks",
      "subject": "rust",
      "title": "Separate lexical paths from filesystem traversal",
      "objective": "Validate a portable relative path grammar, classify entries without following links and publish a sorted complete walk only after every traversal succeeds.",
      "unit_id": "rust.course.foundations.09-portable-paths-and-walks",
      "path": "/curriculum/rust?unit=rust.course.foundations.09-portable-paths-and-walks",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "rust.lesson.configuration-presence",
      "subject": "rust",
      "title": "Let Option carry explicit configuration presence",
      "objective": "Resolve layered settings without treating false, zero or an empty present choice as absence, then replace state only after the combined invariant is valid.",
      "unit_id": "rust.course.foundations.10-configuration-presence",
      "path": "/curriculum/rust?unit=rust.course.foundations.10-configuration-presence",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "rust.lesson.deterministic-collections",
      "subject": "rust",
      "title": "Keep batches and priorities stable without extra bounds",
      "objective": "Traverse borrowed collections with guaranteed progress and order owned priority work by explicit keys rather than payload accidents.",
      "unit_id": "rust.course.foundations.11-deterministic-collections",
      "path": "/curriculum/rust?unit=rust.course.foundations.11-deterministic-collections",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "rust.lesson.streams-and-files",
      "subject": "rust",
      "title": "Observe buffered completion before publication",
      "objective": "Complete short writes, preserve write and flush failure categories, and rename only an exclusively acquired prepared file whose owned handles have settled.",
      "unit_id": "rust.course.foundations.12-streams-and-files",
      "path": "/curriculum/rust?unit=rust.course.foundations.12-streams-and-files",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "rust.lesson.joined-concurrency",
      "subject": "rust",
      "title": "Borrow into scoped workers and observe every outcome",
      "objective": "Bound scoped concurrency, borrow only within the scope, join every worker after success or panic, and publish results in input order without partial output.",
      "unit_id": "rust.course.foundations.13-joined-concurrency",
      "path": "/curriculum/rust?unit=rust.course.foundations.13-joined-concurrency",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "rust.lesson.one-time-cache-publication",
      "subject": "rust",
      "title": "Initialize once and cache only committed data",
      "objective": "Use one synchronization boundary for shared initialization and keep failed persistence or stale reads from becoming advertised cache state.",
      "unit_id": "rust.course.foundations.14-one-time-cache-publication",
      "path": "/curriculum/rust?unit=rust.course.foundations.14-one-time-cache-publication",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "rust.lesson.retry-and-error-context",
      "subject": "rust",
      "title": "Retry one classified failure and retain its source",
      "objective": "Bound deterministic retry effects while preserving path and source context for failures that cross a filesystem or service boundary.",
      "unit_id": "rust.course.foundations.15-retry-and-error-context",
      "path": "/curriculum/rust?unit=rust.course.foundations.15-retry-and-error-context",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "rust.lesson.state-machine-transactions",
      "subject": "rust",
      "title": "Represent legal transitions and stage the batch",
      "objective": "Use enums to make lifecycle states explicit and apply a command batch to private owned state before replacing the caller-visible value.",
      "unit_id": "rust.course.foundations.16-state-machine-transactions",
      "path": "/curriculum/rust?unit=rust.course.foundations.16-state-machine-transactions",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "rust.lesson.synchronization-recovery",
      "subject": "rust",
      "title": "Match atomic ordering and poison recovery to the invariant",
      "objective": "Use one atomic read-modify-write for independent counters and clear mutex poison only after protected state has been inspected and repaired.",
      "unit_id": "rust.course.foundations.17-synchronization-recovery",
      "path": "/curriculum/rust?unit=rust.course.foundations.17-synchronization-recovery",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "rust.lesson.channel-and-socket-lifetimes",
      "subject": "rust",
      "title": "Let sender ownership and socket timeouts define completion",
      "objective": "Drain channels until every sender is gone and complete a framed local socket exchange while the acquired connection and its timeouts remain owned.",
      "unit_id": "rust.course.foundations.18-channel-and-socket-lifetimes",
      "path": "/curriculum/rust?unit=rust.course.foundations.18-channel-and-socket-lifetimes",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "rust.lesson.library-consumer-transfer",
      "subject": "rust",
      "title": "Expose a narrow library contract and commit once",
      "objective": "Compose typed library steps and import a bounded framed batch without leaking parser details, partial state or unobserved failure into its consumer.",
      "unit_id": "rust.course.foundations.19-library-consumer-transfer",
      "path": "/curriculum/rust?unit=rust.course.foundations.19-library-consumer-transfer",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "rust.lesson.cleanup-and-child-processes",
      "subject": "rust",
      "title": "Consume cleanup once and observe the child completely",
      "objective": "Own reverse-order FnOnce compensation and return a local child process outcome with stdout, stderr and exit status all preserved.",
      "unit_id": "rust.course.foundations.20-cleanup-and-child-processes",
      "path": "/curriculum/rust?unit=rust.course.foundations.20-cleanup-and-child-processes",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "c.lesson.representation-and-arithmetic",
      "subject": "c",
      "title": "Prove arithmetic fits before evaluating it",
      "objective": "Make widths, signedness and text grammar explicit, and preserve the caller output whenever a C arithmetic or parsing operation is invalid.",
      "unit_id": "c.course.foundations.01-representation-and-arithmetic",
      "path": "/curriculum/c?unit=c.course.foundations.01-representation-and-arithmetic",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "c.lesson.strict-scalar-parsing",
      "subject": "c",
      "title": "Parse the whole scalar before publishing it",
      "objective": "Validate fixed grammar, range and calendar rules without accepting prefixes, locale variation or a partially written output.",
      "unit_id": "c.course.foundations.02-strict-scalar-parsing",
      "path": "/curriculum/c?unit=c.course.foundations.02-strict-scalar-parsing",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "c.lesson.pointers-arrays-and-strings",
      "subject": "c",
      "title": "Carry the bound with every borrowed pointer",
      "objective": "Validate length, capacity, termination and aliasing before touching a C buffer, including a source range inside the destination allocation.",
      "unit_id": "c.course.foundations.03-pointers-arrays-and-strings",
      "path": "/curriculum/c?unit=c.course.foundations.03-pointers-arrays-and-strings",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "c.lesson.iteration-contracts",
      "subject": "c",
      "title": "State the valid range before the first read",
      "objective": "Express iteration with size_t bounds that handle empty and singleton ranges without underflow, distinguish not-found from index zero, and touch only the declared span.",
      "unit_id": "c.course.foundations.04-iteration-contracts",
      "path": "/curriculum/c?unit=c.course.foundations.04-iteration-contracts",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "c.lesson.utf8-and-identifiers",
      "subject": "c",
      "title": "Validate encoded text before normalizing it",
      "objective": "Read exactly the supplied byte span as strict UTF-8 or a portable ASCII identifier, with explicit NUL and capacity policy.",
      "unit_id": "c.course.foundations.05-utf8-and-identifiers",
      "path": "/curriculum/c?unit=c.course.foundations.05-utf8-and-identifiers",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "c.lesson.encoded-text-boundaries",
      "subject": "c",
      "title": "Decode into a staged text buffer",
      "objective": "Validate percent escapes, HTTP field controls and quoted-field grammar before overlap-safe publication with one explicit terminator policy.",
      "unit_id": "c.course.foundations.06-encoded-text-boundaries",
      "path": "/curriculum/c?unit=c.course.foundations.06-encoded-text-boundaries",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "c.lesson.portable-binary-framing",
      "subject": "c",
      "title": "Decode bits and prefixes without host assumptions",
      "objective": "Read canonical variable-length integers and bounded signed bit fields using explicit byte order, width and publication rules.",
      "unit_id": "c.course.foundations.07-portable-binary-framing",
      "path": "/curriculum/c?unit=c.course.foundations.07-portable-binary-framing",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "c.lesson.bounded-formatting",
      "subject": "c",
      "title": "Treat formatted length as a checked result",
      "objective": "Measure complete formatted output, preserve variadic type information and write borrowed sinks only after one bounded record is ready.",
      "unit_id": "c.course.foundations.08-bounded-formatting",
      "path": "/curriculum/c?unit=c.course.foundations.08-bounded-formatting",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "c.lesson.path-and-file-copy",
      "subject": "c",
      "title": "Validate the whole source before touching the destination",
      "objective": "Normalize portable relative paths lexically and stage bounded file input so oversize or malformed source data cannot partially publish.",
      "unit_id": "c.course.foundations.09-path-and-file-copy",
      "path": "/curriculum/c?unit=c.course.foundations.09-path-and-file-copy",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "c.lesson.borrowed-spans-and-previews",
      "subject": "c",
      "title": "Name borrowed views and detached copies separately",
      "objective": "Return span offsets into caller storage when borrowing and allocate or fill independent preview bytes only after complete capacity validation.",
      "unit_id": "c.course.foundations.10-borrowed-spans-and-previews",
      "path": "/curriculum/c?unit=c.course.foundations.10-borrowed-spans-and-previews",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "c.lesson.allocation-and-cleanup",
      "subject": "c",
      "title": "Commit new ownership only after allocation succeeds",
      "objective": "Preserve prior valid state across allocation failure and unwind each successfully acquired allocation exactly once in reverse construction order.",
      "unit_id": "c.course.foundations.11-allocation-and-cleanup",
      "path": "/curriculum/c?unit=c.course.foundations.11-allocation-and-cleanup",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "c.lesson.files-and-protocol-input",
      "subject": "c",
      "title": "Drain the record and publish only a valid decode",
      "objective": "Own FILE state across short input and errors, enforce byte and grammar bounds before retention, and leave destination data untouched when a complete record cannot be decoded.",
      "unit_id": "c.course.foundations.12-files-and-protocol-input",
      "path": "/curriculum/c?unit=c.course.foundations.12-files-and-protocol-input",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "c.lesson.checksums-and-bitwise-invariants",
      "subject": "c",
      "title": "Verify integrity before copying payload bytes",
      "objective": "Compute portable network checksums and validate a record CRC before publishing an overlap-safe payload or its used length.",
      "unit_id": "c.course.foundations.13-checksums-and-bitwise-invariants",
      "path": "/curriculum/c?unit=c.course.foundations.13-checksums-and-bitwise-invariants",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "c.lesson.transactional-buffer-edits",
      "subject": "c",
      "title": "Validate every edit before moving bytes",
      "objective": "Apply alias-safe range replacements or an index-removal batch only after shape, size, order and capacity have all been proved.",
      "unit_id": "c.course.foundations.14-transactional-buffer-edits",
      "path": "/curriculum/c?unit=c.course.foundations.14-transactional-buffer-edits",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "c.lesson.owned-linked-structures",
      "subject": "c",
      "title": "Move list ownership without recreating nodes",
      "objective": "Filter and merge acyclic malloc-owned lists while preserving survivor identity, deterministic tie order and exactly-once deallocation.",
      "unit_id": "c.course.foundations.15-owned-linked-structures",
      "path": "/curriculum/c?unit=c.course.foundations.15-owned-linked-structures",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "c.lesson.stable-handles-and-interning",
      "subject": "c",
      "title": "Keep identity valid across reuse and growth",
      "objective": "Reject stale pool handles with generations and return stable interned string pointers whose storage is owned independently of caller buffers.",
      "unit_id": "c.course.foundations.16-stable-handles-and-interning",
      "path": "/curriculum/c?unit=c.course.foundations.16-stable-handles-and-interning",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "c.lesson.file-record-imports",
      "subject": "c",
      "title": "Stage complete records across file boundaries",
      "objective": "Import whole big-endian records atomically and find a byte pattern incrementally even when it crosses an internal read boundary.",
      "unit_id": "c.course.foundations.17-file-record-imports",
      "path": "/curriculum/c?unit=c.course.foundations.17-file-record-imports",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "c.lesson.cleanup-and-callback-cancellation",
      "subject": "c",
      "title": "Observe cancellation between effects and unwind all ownership",
      "objective": "Check cancellation before each callback effect and consume registered cleanups in reverse order even after one cleanup reports failure.",
      "unit_id": "c.course.foundations.18-cleanup-and-callback-cancellation",
      "path": "/curriculum/c?unit=c.course.foundations.18-cleanup-and-callback-cancellation",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "c.lesson.instrumented-parser-transfer",
      "subject": "c",
      "title": "Treat instrumentation and atomic publication as evidence",
      "objective": "Combine bounded framing, integrity, checked state transitions and final publication, while interpreting supplied instrumentation output without mistaking silence for a clean run.",
      "unit_id": "c.course.foundations.19-instrumented-parser-transfer",
      "path": "/curriculum/c?unit=c.course.foundations.19-instrumented-parser-transfer",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "c.lesson.bounded-dependency-transactions",
      "subject": "c",
      "title": "Plan the whole bounded state change before commit",
      "objective": "Produce a deterministic dependency order and apply a registry command batch with private staging and complete rollback on any invalid command.",
      "unit_id": "c.course.foundations.20-bounded-dependency-transactions",
      "path": "/curriculum/c?unit=c.course.foundations.20-bounded-dependency-transactions",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "cpp.lesson.values-views-and-lifetime",
      "subject": "cpp",
      "title": "Keep every C++ view inside its source lifetime",
      "objective": "Distinguish values, references and views, then return owned data whenever a result must outlive its source.",
      "unit_id": "cpp.course.foundations.01-values-views-and-lifetime",
      "path": "/curriculum/cpp?unit=cpp.course.foundations.01-values-views-and-lifetime",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "cpp.lesson.raii-and-acquisition",
      "subject": "cpp",
      "title": "Acquire C++ resources into immediate owners",
      "objective": "Represent every successful acquisition with an owner and unwind partial construction without losing the primary failure.",
      "unit_id": "cpp.course.foundations.02-raii-and-acquisition",
      "path": "/curriculum/cpp?unit=cpp.course.foundations.02-raii-and-acquisition",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "cpp.lesson.containers-and-algorithms",
      "subject": "cpp",
      "title": "Preserve C++ container invariants during algorithms",
      "objective": "Choose container operations by invalidation, ordering and exception guarantees rather than convenience.",
      "unit_id": "cpp.course.foundations.03-containers-and-algorithms",
      "path": "/curriculum/cpp?unit=cpp.course.foundations.03-containers-and-algorithms",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "cpp.lesson.moves-and-value-categories",
      "subject": "cpp",
      "title": "Move C++ ownership without inventing source state",
      "objective": "Use move operations to transfer owned resources while relying only on the moved-from type contract.",
      "unit_id": "cpp.course.foundations.04-moves-and-value-categories",
      "path": "/curriculum/cpp?unit=cpp.course.foundations.04-moves-and-value-categories",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "cpp.lesson.generic-api-contracts",
      "subject": "cpp",
      "title": "Constrain a C++ generic API to what it uses",
      "objective": "Express the actual operations a template requires while preserving heterogeneous lookup and typed command relationships.",
      "unit_id": "cpp.course.foundations.05-generic-api-contracts",
      "path": "/curriculum/cpp?unit=cpp.course.foundations.05-generic-api-contracts",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "cpp.lesson.exceptions-and-concurrency",
      "subject": "cpp",
      "title": "Observe concurrent C++ work before returning",
      "objective": "Retain exception authority, close concurrent state explicitly and join every started task before reporting an outcome.",
      "unit_id": "cpp.course.foundations.06-exceptions-and-concurrency",
      "path": "/curriculum/cpp?unit=cpp.course.foundations.06-exceptions-and-concurrency",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "cpp.lesson.shared-and-weak-ownership",
      "subject": "cpp",
      "title": "Separate shared ownership from observation",
      "objective": "Use shared_ptr, weak_ptr and aliasing ownership according to lifetime authority rather than pointer shape.",
      "unit_id": "cpp.course.foundations.07-shared-and-weak-ownership",
      "path": "/curriculum/cpp?unit=cpp.course.foundations.07-shared-and-weak-ownership",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "cpp.lesson.node-handles-and-stable-identity",
      "subject": "cpp",
      "title": "Rename map identity without losing its node",
      "objective": "Use node handles to transfer an existing allocation and restore ownership when insertion cannot commit.",
      "unit_id": "cpp.course.foundations.08-node-handles-and-stable-identity",
      "path": "/curriculum/cpp?unit=cpp.course.foundations.08-node-handles-and-stable-identity",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "cpp.lesson.memory-resources-and-budgets",
      "subject": "cpp",
      "title": "Make a C++ allocation budget real",
      "objective": "Bind polymorphic allocation to a caller-owned resource and fail instead of silently escaping a fixed budget.",
      "unit_id": "cpp.course.foundations.09-memory-resources-and-budgets",
      "path": "/curriculum/cpp?unit=cpp.course.foundations.09-memory-resources-and-budgets",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "cpp.lesson.parsing-and-exact-numbers",
      "subject": "cpp",
      "title": "Parse complete C++ numeric records",
      "objective": "Use bounded locale-independent conversion and require complete grammar before publishing an exact number.",
      "unit_id": "cpp.course.foundations.10-parsing-and-exact-numbers",
      "path": "/curriculum/cpp?unit=cpp.course.foundations.10-parsing-and-exact-numbers",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "cpp.lesson.chrono-and-calendar-values",
      "subject": "cpp",
      "title": "Validate C++ calendar values before arithmetic",
      "objective": "Keep civil dates distinct from local instants and use chrono validity before computing an epoch offset.",
      "unit_id": "cpp.course.foundations.11-chrono-and-calendar-values",
      "path": "/curriculum/cpp?unit=cpp.course.foundations.11-chrono-and-calendar-values",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "cpp.lesson.binary-representation",
      "subject": "cpp",
      "title": "Decode C++ binary values without alignment assumptions",
      "objective": "Assemble endian-defined bits from bytes, preserve finite representations and avoid aliased or unaligned loads.",
      "unit_id": "cpp.course.foundations.12-binary-representation",
      "path": "/curriculum/cpp?unit=cpp.course.foundations.12-binary-representation",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "cpp.lesson.streams-and-records",
      "subject": "cpp",
      "title": "Read complete C++ stream records",
      "objective": "Distinguish EOF, extraction failure, trailing input and exact quoted record grammar while retaining caller stream ownership.",
      "unit_id": "cpp.course.foundations.13-streams-and-records",
      "path": "/curriculum/cpp?unit=cpp.course.foundations.13-streams-and-records",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "cpp.lesson.ranges-and-owned-results",
      "subject": "cpp",
      "title": "Materialize C++ range results at the boundary",
      "objective": "Compose lazy range operations internally and return an owned, correctly widened result across lifetime boundaries.",
      "unit_id": "cpp.course.foundations.14-ranges-and-owned-results",
      "path": "/curriculum/cpp?unit=cpp.course.foundations.14-ranges-and-owned-results",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "cpp.lesson.library-transfer",
      "subject": "cpp",
      "title": "Return explicit results from a C++ library boundary",
      "objective": "Translate nested failures and ordinary filesystem outcomes into an owned, documented library result.",
      "unit_id": "cpp.course.foundations.15-library-transfer",
      "path": "/curriculum/cpp?unit=cpp.course.foundations.15-library-transfer",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "cpp.lesson.files-and-directories",
      "subject": "cpp",
      "title": "Publish and inventory C++ filesystem state",
      "objective": "Stage a complete file under owned paths and produce a deterministic directory inventory without following links.",
      "unit_id": "cpp.course.foundations.16-files-and-directories",
      "path": "/curriculum/cpp?unit=cpp.course.foundations.16-files-and-directories",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "cpp.lesson.stop-aware-coordination",
      "subject": "cpp",
      "title": "Wake and join stopped C++ work",
      "objective": "Make cooperative stop participate in blocking waits and observe every asynchronous result before scope exit.",
      "unit_id": "cpp.course.foundations.17-stop-aware-coordination",
      "path": "/curriculum/cpp?unit=cpp.course.foundations.17-stop-aware-coordination",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "cpp.lesson.typed-state-machines",
      "subject": "cpp",
      "title": "Apply C++ typed commands transactionally",
      "objective": "Use variant alternatives as explicit commands and commit a dependent batch only after every precondition succeeds.",
      "unit_id": "cpp.course.foundations.18-typed-state-machines",
      "path": "/curriculum/cpp?unit=cpp.course.foundations.18-typed-state-machines",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "cpp.lesson.synchronized-snapshots",
      "subject": "cpp",
      "title": "Read one correlated C++ state generation",
      "objective": "Protect related fields under one shared/exclusive lock and return a detached snapshot from a single generation.",
      "unit_id": "cpp.course.foundations.19-synchronized-snapshots",
      "path": "/curriculum/cpp?unit=cpp.course.foundations.19-synchronized-snapshots",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "cpp.lesson.native-library-capstone",
      "subject": "cpp",
      "title": "Deliver an all-or-nothing C++ import library",
      "objective": "Combine complete stream parsing, checked accumulation, deterministic state change and explicit failure into a reusable library operation.",
      "unit_id": "cpp.course.foundations.20-native-library-capstone",
      "path": "/curriculum/cpp?unit=cpp.course.foundations.20-native-library-capstone",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "csharp.lesson.values-and-nullability",
      "subject": "csharp",
      "title": "Observe nullable presence in C# values",
      "objective": "Separate compiler null-state analysis from runtime checks, format constructed contacts by nullable presence and classify nullable integers without losing zero.",
      "unit_id": "csharp.course.foundations.01-values-and-nullability",
      "path": "/curriculum/csharp?unit=csharp.course.foundations.01-values-and-nullability",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "csharp.lesson.collections-and-linq",
      "subject": "csharp",
      "title": "Control when a C# query runs",
      "objective": "Choose deferred or materialized execution deliberately, enumerate one-shot sources once and preserve exact key identity.",
      "unit_id": "csharp.course.foundations.02-collections-and-linq",
      "path": "/curriculum/csharp?unit=csharp.course.foundations.02-collections-and-linq",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "csharp.lesson.json-and-configuration",
      "subject": "csharp",
      "title": "Decode strict C# configuration documents",
      "objective": "Reject duplicate authority, validate exact JSON shape and detach accepted values before parser lifetime ends.",
      "unit_id": "csharp.course.foundations.03-json-and-configuration",
      "path": "/curriculum/csharp?unit=csharp.course.foundations.03-json-and-configuration",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "csharp.lesson.configuration-and-command-lines",
      "subject": "csharp",
      "title": "Resolve C# configuration by presence",
      "objective": "Apply explicit layer precedence and parse one detached command line without false-like fallback or process mutation.",
      "unit_id": "csharp.course.foundations.04-configuration-and-command-lines",
      "path": "/curriculum/csharp?unit=csharp.course.foundations.04-configuration-and-command-lines",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "csharp.lesson.async-and-cancellation",
      "subject": "csharp",
      "title": "Own C# asynchronous work through settlement",
      "objective": "Propagate cancellation, bound admitted callbacks, preserve result order and observe the complete task group.",
      "unit_id": "csharp.course.foundations.05-async-and-cancellation",
      "path": "/curriculum/csharp?unit=csharp.course.foundations.05-async-and-cancellation",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "csharp.lesson.resources-and-type-relationships",
      "subject": "csharp",
      "title": "Dispose every acquired C# resource",
      "objective": "Pair synchronous and asynchronous acquisition with complete cleanup while retaining all observed failures.",
      "unit_id": "csharp.course.foundations.06-resources-and-type-relationships",
      "path": "/curriculum/csharp?unit=csharp.course.foundations.06-resources-and-type-relationships",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "csharp.lesson.unicode-and-text-boundaries",
      "subject": "csharp",
      "title": "Validate C# Unicode before applying a byte budget",
      "objective": "Keep UTF-16 code units, Unicode scalar values and UTF-8 bytes distinct through strict decoding and truncation.",
      "unit_id": "csharp.course.foundations.07-unicode-and-text-boundaries",
      "path": "/curriculum/csharp?unit=csharp.course.foundations.07-unicode-and-text-boundaries",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "csharp.lesson.exact-numeric-and-time-values",
      "subject": "csharp",
      "title": "Parse exact C# money and instants",
      "objective": "Convert exact decimal and zoned time grammars without machine culture, floating rounding or local timezone authority.",
      "unit_id": "csharp.course.foundations.08-exact-numeric-and-time-values",
      "path": "/curriculum/csharp?unit=csharp.course.foundations.08-exact-numeric-and-time-values",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "csharp.lesson.binary-framing-and-compression",
      "subject": "csharp",
      "title": "Bound C# binary expansion and frame integrity",
      "objective": "Encode portable byte order, verify checksums as integrity evidence and bound decompressed output before publication.",
      "unit_id": "csharp.course.foundations.09-binary-framing-and-compression",
      "path": "/curriculum/csharp?unit=csharp.course.foundations.09-binary-framing-and-compression",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "csharp.lesson.channels-and-async-streams",
      "subject": "csharp",
      "title": "Drain asynchronous C# sequences through completion",
      "objective": "Propagate enumerator cancellation, dispose async iterators and distinguish buffered channel data from final completion.",
      "unit_id": "csharp.course.foundations.10-channels-and-async-streams",
      "path": "/curriculum/csharp?unit=csharp.course.foundations.10-channels-and-async-streams",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "csharp.lesson.task-outcomes-and-timeouts",
      "subject": "csharp",
      "title": "Preserve C# task outcomes under a wait policy",
      "objective": "Observe every task, retain input order and distinguish timeout, caller cancellation and underlying task failure.",
      "unit_id": "csharp.course.foundations.11-task-outcomes-and-timeouts",
      "path": "/curriculum/csharp?unit=csharp.course.foundations.11-task-outcomes-and-timeouts",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "csharp.lesson.paths-and-directory-inventory",
      "subject": "csharp",
      "title": "Keep C# paths inside their declared boundary",
      "objective": "Validate portable relative paths and produce a deterministic inventory without treating lexical policy as symlink authority.",
      "unit_id": "csharp.course.foundations.12-paths-and-directory-inventory",
      "path": "/curriculum/csharp?unit=csharp.course.foundations.12-paths-and-directory-inventory",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "csharp.lesson.reflection-and-schema",
      "subject": "csharp",
      "title": "Inspect C# metadata without invoking application code",
      "objective": "Derive a stable public schema from declared metadata while excluding getters, indexers and inherited opt-out authority.",
      "unit_id": "csharp.course.foundations.13-reflection-and-schema",
      "path": "/curriculum/csharp?unit=csharp.course.foundations.13-reflection-and-schema",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "csharp.lesson.immutable-models-and-flags",
      "subject": "csharp",
      "title": "Publish valid C# models and capability masks",
      "objective": "Reject unknown or dependent flag combinations and detach mutable nested data in immutable record updates.",
      "unit_id": "csharp.course.foundations.14-immutable-models-and-flags",
      "path": "/curriculum/csharp?unit=csharp.course.foundations.14-immutable-models-and-flags",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "csharp.lesson.streams-pools-and-digests",
      "subject": "csharp",
      "title": "Read exact C# streams and return pooled memory",
      "objective": "Handle short asynchronous reads, hash only observed bytes and return an acquired pool buffer once on every outcome.",
      "unit_id": "csharp.course.foundations.15-streams-pools-and-digests",
      "path": "/curriculum/csharp?unit=csharp.course.foundations.15-streams-pools-and-digests",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "csharp.lesson.single-flight-async-state",
      "subject": "csharp",
      "title": "Consume C# ValueTask results exactly once",
      "objective": "Observe one source-backed ValueTask exactly once, then transfer that ownership rule to an ordered batch without changing outcome identity.",
      "unit_id": "csharp.course.foundations.16-single-flight-async-state",
      "path": "/curriculum/csharp?unit=csharp.course.foundations.16-single-flight-async-state",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "csharp.lesson.application-feature-transfer",
      "subject": "csharp",
      "title": "Import an authenticated C# ledger atomically",
      "objective": "Authenticate framing, parse exact records, stage dependent changes and publish application state once.",
      "unit_id": "csharp.course.foundations.17-application-feature-transfer",
      "path": "/curriculum/csharp?unit=csharp.course.foundations.17-application-feature-transfer",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "csharp.lesson.filesystem-publication",
      "subject": "csharp",
      "title": "Publish complete C# files from an acquired stage",
      "objective": "Use exclusive acquisition and same-directory staging so existing destinations and unowned files survive failure.",
      "unit_id": "csharp.course.foundations.18-filesystem-publication",
      "path": "/curriculum/csharp?unit=csharp.course.foundations.18-filesystem-publication",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "csharp.lesson.plugins-and-activation",
      "subject": "csharp",
      "title": "Discover before activating C# plugins",
      "objective": "Separate side-effect-free type discovery from validated construction and preserve a constructor failure cause.",
      "unit_id": "csharp.course.foundations.19-plugins-and-activation",
      "path": "/curriculum/csharp?unit=csharp.course.foundations.19-plugins-and-activation",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "csharp.lesson.cryptographic-records",
      "subject": "csharp",
      "title": "Authenticate C# records before releasing plaintext",
      "objective": "Distinguish hashing, MAC and authenticated encryption while enforcing canonical key and frame representations.",
      "unit_id": "csharp.course.foundations.20-cryptographic-records",
      "path": "/curriculum/csharp?unit=csharp.course.foundations.20-cryptographic-records",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "aspnet.lesson.syllabus-01-middleware-by-hand",
      "subject": "aspnet",
      "title": "Short-circuit a maintenance guard before endpoint execution",
      "objective": "Short-circuit maintenance requests before the endpoint and otherwise await the existing downstream request delegate once.",
      "unit_id": "aspnet.course.foundations.01-middleware-by-hand",
      "path": "/curriculum/aspnet?unit=aspnet.course.foundations.01-middleware-by-hand",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "aspnet.lesson.syllabus-02-validate-the-exact-route-value-representation",
      "subject": "aspnet",
      "title": "Collect declared endpoint tags without losing insertion order or distinct spelling",
      "objective": "Read actual endpoint tags in declaration order, omitting empty values while keeping distinct ordinal spellings.",
      "unit_id": "aspnet.course.foundations.02-validate-the-exact-route-value-representation",
      "path": "/curriculum/aspnet?unit=aspnet.course.foundations.02-validate-the-exact-route-value-representation",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "aspnet.lesson.syllabus-03-build-a-created-result-with-an-escaped-owned-location",
      "subject": "aspnet",
      "title": "Publish a UTF8 JSON response with byte length and borrowed stream ownership",
      "objective": "Write the declared JSON response as UTF-8 bytes, publish its byte length and retain caller ownership of the response stream.",
      "unit_id": "aspnet.course.foundations.03-build-a-created-result-with-an-escaped-owned-location",
      "path": "/curriculum/aspnet?unit=aspnet.course.foundations.03-build-a-created-result-with-an-escaped-owned-location",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "aspnet.lesson.syllabus-04-reject-invalid-input-before-acquiring-a-write",
      "subject": "aspnet",
      "title": "Headers the browser will actually enforce",
      "objective": "Apply security-header policy without overwriting caller CSP or enabling HTTPS-only behavior for an HTTP request.",
      "unit_id": "aspnet.course.foundations.04-reject-invalid-input-before-acquiring-a-write",
      "path": "/curriculum/aspnet?unit=aspnet.course.foundations.04-reject-invalid-input-before-acquiring-a-write",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "aspnet.lesson.syllabus-05-request-cleanup-survives-handler-failure",
      "subject": "aspnet",
      "title": "Register one scoped service without capturing it at the root",
      "objective": "Register one scoped service in the actual container and reject resolving that scoped lifetime from the root provider.",
      "unit_id": "aspnet.course.foundations.05-request-cleanup-survives-handler-failure",
      "path": "/curriculum/aspnet?unit=aspnet.course.foundations.05-request-cleanup-survives-handler-failure",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "aspnet.lesson.syllabus-06-configuration",
      "subject": "aspnet",
      "title": "Accept a bounded request correlation ID without copying arbitrary text",
      "objective": "Accept one bounded request correlation ID or invoke the trusted fallback instead of copying arbitrary or repeated header text.",
      "unit_id": "aspnet.course.foundations.06-configuration",
      "path": "/curriculum/aspnet?unit=aspnet.course.foundations.06-configuration",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "aspnet.lesson.syllabus-07-backfill-only-missing-values",
      "subject": "aspnet",
      "title": "Restore an existing request item after temporary scoped use",
      "objective": "Temporarily replace a request item and restore its exact former presence and value after awaited downstream work.",
      "unit_id": "aspnet.course.foundations.07-backfill-only-missing-values",
      "path": "/curriculum/aspnet?unit=aspnet.course.foundations.07-backfill-only-missing-values",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "aspnet.lesson.syllabus-08-read-the-selected-endpoint-effective-metadata-without-",
      "subject": "aspnet",
      "title": "Validate configured options through the actual options service",
      "objective": "Validate configured options through actual options acquisition before treating the configured value as usable.",
      "unit_id": "aspnet.course.foundations.08-read-the-selected-endpoint-effective-metadata-without-",
      "path": "/curriculum/aspnet?unit=aspnet.course.foundations.08-read-the-selected-endpoint-effective-metadata-without-",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "aspnet.lesson.syllabus-09-reject-an-ambiguous-or-foreign-origin-before-state-mut",
      "subject": "aspnet",
      "title": "Construct actual problem details with stable public fields and no internal failure text",
      "objective": "Construct stable public problem fields and a request trace identifier without exposing internal exception details.",
      "unit_id": "aspnet.course.foundations.09-reject-an-ambiguous-or-foreign-origin-before-state-mut",
      "path": "/curriculum/aspnet?unit=aspnet.course.foundations.09-reject-an-ambiguous-or-foreign-origin-before-state-mut",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "aspnet.lesson.syllabus-10-snapshot-actual-header-values-without-sharing-mutable-",
      "subject": "aspnet",
      "title": "Saying no with the right status",
      "objective": "Validate every request field, retain ordered field errors and accept legitimate boundary values such as age zero.",
      "unit_id": "aspnet.course.foundations.10-snapshot-actual-header-values-without-sharing-mutable-",
      "path": "/curriculum/aspnet?unit=aspnet.course.foundations.10-snapshot-actual-header-values-without-sharing-mutable-",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "aspnet.lesson.syllabus-11-one-error-boundary",
      "subject": "aspnet",
      "title": "Acquire one subject only from authenticated identities",
      "objective": "Select one distinct subject only from authenticated identities, rejecting contradictory authenticated authority.",
      "unit_id": "aspnet.course.foundations.11-one-error-boundary",
      "path": "/curriculum/aspnet?unit=aspnet.course.foundations.11-one-error-boundary",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "aspnet.lesson.syllabus-12-fence-a-protected-request-with-authentication-before-p",
      "subject": "aspnet",
      "title": "Fence a protected request with authentication before permission and downstream work",
      "objective": "Authenticate before permission checks and run protected downstream work only after both gates accept the request.",
      "unit_id": "aspnet.course.foundations.12-fence-a-protected-request-with-authentication-before-p",
      "path": "/curriculum/aspnet?unit=aspnet.course.foundations.12-fence-a-protected-request-with-authentication-before-p",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "aspnet.lesson.syllabus-13-reject-invalid-limiter-configuration-before-constructi",
      "subject": "aspnet",
      "title": "Reject invalid limiter configuration before constructing its request delegate",
      "objective": "Reject invalid admission configuration before invoking its delegate factory and retain the acquired delegate identity.",
      "unit_id": "aspnet.course.foundations.13-reject-invalid-limiter-configuration-before-constructi",
      "path": "/curriculum/aspnet?unit=aspnet.course.foundations.13-reject-invalid-limiter-configuration-before-constructi",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "aspnet.lesson.syllabus-14-read-the-generated-sql",
      "subject": "aspnet",
      "title": "A read result cannot edit tracked storage",
      "objective": "Return detached record arrays as well as a detached dictionary so neither direction of mutation can rewrite storage.",
      "unit_id": "aspnet.course.foundations.14-read-the-generated-sql",
      "path": "/curriculum/aspnet?unit=aspnet.course.foundations.14-read-the-generated-sql",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "aspnet.lesson.syllabus-15-saving-and-the-transaction",
      "subject": "aspnet",
      "title": "Restore Path and PathBase after a bounded branch",
      "objective": "Apply an actual path-segment branch temporarily and restore both Path and PathBase after downstream success or failure.",
      "unit_id": "aspnet.course.foundations.15-saving-and-the-transaction",
      "path": "/curriculum/aspnet?unit=aspnet.course.foundations.15-saving-and-the-transaction",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "aspnet.lesson.syllabus-16-reject-overlap-without-manufacturing-a-queued-request",
      "subject": "aspnet",
      "title": "Apply a complete conditional-write gate before invoking mutation",
      "objective": "Require exactly one matching conditional-write token before invoking mutation, distinguishing missing from failed preconditions.",
      "unit_id": "aspnet.course.foundations.16-reject-overlap-without-manufacturing-a-queued-request",
      "path": "/curriculum/aspnet?unit=aspnet.course.foundations.16-reject-overlap-without-manufacturing-a-queued-request",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "aspnet.lesson.syllabus-17-reject-a-singleton-capturing-a-scoped-dependency-durin",
      "subject": "aspnet",
      "title": "Temporarily install request services without erasing prior owner",
      "objective": "Install borrowed request services only for awaited downstream work and restore the previous provider without disposing either owner.",
      "unit_id": "aspnet.course.foundations.17-reject-a-singleton-capturing-a-scoped-dependency-durin",
      "path": "/curriculum/aspnet?unit=aspnet.course.foundations.17-reject-a-singleton-capturing-a-scoped-dependency-durin",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "aspnet.lesson.syllabus-18-evaluate-actual-authorization-policy-with-both-require",
      "subject": "aspnet",
      "title": "Install one actual request item feature only for the downstream lifetime",
      "objective": "Temporarily install an items feature and restore the exact previous feature without clearing caller dictionaries.",
      "unit_id": "aspnet.course.foundations.18-evaluate-actual-authorization-policy-with-both-require",
      "path": "/curriculum/aspnet?unit=aspnet.course.foundations.18-evaluate-actual-authorization-policy-with-both-require",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "aspnet.lesson.syllabus-19-separate-canceled-request-lifetime-from-an-application",
      "subject": "aspnet",
      "title": "Keep one cancellation callback registration alive only during awaited request work",
      "objective": "Keep a cancellation callback registration alive only for awaited request work and release it without disposing the caller’s token source.",
      "unit_id": "aspnet.course.foundations.19-separate-canceled-request-lifetime-from-an-application",
      "path": "/curriculum/aspnet?unit=aspnet.course.foundations.19-separate-canceled-request-lifetime-from-an-application",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "aspnet.lesson.syllabus-20-the-n-1",
      "subject": "aspnet",
      "title": "Snapshot tracked fields before mutation",
      "objective": "Snapshot mutable tracked fields under ordinal key identity so later edits cannot rewrite the accepted baseline.",
      "unit_id": "aspnet.course.foundations.20-the-n-1",
      "path": "/curriculum/aspnet?unit=aspnet.course.foundations.20-the-n-1",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "L01",
      "subject": "application-security",
      "title": "Read another user's document",
      "objective": "Find an ownership failure by changing one document identifier. Repair retrieval without breaking authorized shared reading.",
      "unit_id": "app-access",
      "path": "/security?track=application-security&lab=L01&activity=theory",
      "public_teaching": true,
      "plans": ["free", "web", "plus", "pro"]
    },
    {
      "id": "L02",
      "subject": "application-security",
      "title": "Update another user's document",
      "objective": "Separate read access from editing authority. Verify denied writes leave the original document unchanged.",
      "unit_id": "app-access",
      "path": "/security?track=application-security&lab=L02&activity=theory",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "L03",
      "subject": "application-security",
      "title": "Invoke a restricted action directly",
      "objective": "Test an operation whose button is hidden from members. Enforce role and team authority in the operation itself.",
      "unit_id": "app-access",
      "path": "/security?track=application-security&lab=L03&activity=theory",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "L04",
      "subject": "application-security",
      "title": "Change a protected property",
      "objective": "Repair a mass-assignment failure with explicit writable fields. Preserve protected state even when valid and protected edits are mixed.",
      "unit_id": "app-input",
      "path": "/security?track=application-security&lab=L04&activity=theory",
      "public_teaching": true,
      "plans": ["free", "web", "plus", "pro"]
    },
    {
      "id": "L05",
      "subject": "application-security",
      "title": "Execute untrusted content in a page",
      "objective": "Observe a real browser event handler executing at an unsafe DOM sink. Repair a plain-text feature and preserve its literal content.",
      "unit_id": "app-input",
      "path": "/security?track=application-security&lab=L05&activity=theory",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "L06",
      "subject": "application-security",
      "title": "Persist a malicious comment",
      "objective": "Follow a saved comment into a later persona view. Repair the rendering boundary without deleting legitimate stored comments.",
      "unit_id": "app-input",
      "path": "/security?track=application-security&lab=L06&activity=theory",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "L07",
      "subject": "application-security",
      "title": "Alter a database search",
      "objective": "Change the structure of a query executed by real SQLite. Bind search values and verify quoted names still work.",
      "unit_id": "app-data",
      "path": "/security?track=application-security&lab=L07&activity=theory",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "L08",
      "subject": "application-security",
      "title": "Cross a tenant boundary in a report",
      "objective": "Repair a scoped aggregate using trusted identity and real SQLite parameter semantics. Keep report totals and result shape stable.",
      "unit_id": "app-data",
      "path": "/security?track=application-security&lab=L08&activity=theory",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "L09",
      "subject": "application-security",
      "title": "Manipulate a checkout total",
      "objective": "Replace a client-supplied price with authoritative catalog calculation. Preserve mixed orders and reject invalid quantities.",
      "unit_id": "app-data",
      "path": "/security?track=application-security&lab=L09&activity=theory",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "L10",
      "subject": "application-security",
      "title": "Replay a purchase operation",
      "objective": "Reproduce a duplicate order through sequential replay. Scope idempotency to actor and operation while preserving safe retries.",
      "unit_id": "app-transfer",
      "path": "/security?track=application-security&lab=L10&activity=theory",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "L11",
      "subject": "application-security",
      "title": "Find sensitive details in an error response",
      "objective": "Trigger a malformed request and find a fictional configuration canary. Repair public errors while retaining local diagnostic handling.",
      "unit_id": "app-transfer",
      "path": "/security?track=application-security&lab=L11&activity=theory",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "L12",
      "subject": "application-security",
      "title": "Investigate an unfamiliar document feature",
      "objective": "Investigate a new revision endpoint, reproduce two policy failures, repair both boundaries and execute your own regression checks.",
      "unit_id": "app-transfer",
      "path": "/security?track=application-security&lab=L12&activity=theory",
      "public_teaching": false,
      "plans": ["web", "plus", "pro"]
    },
    {
      "id": "R01",
      "subject": "security-research",
      "title": "Prototype pollution in a settings merge",
      "objective": "Investigate inherited-property behavior in a recursive merge. Repair key handling and preserve legitimate nested settings.",
      "unit_id": "research-authority",
      "path": "/security?track=security-research&lab=R01&activity=theory",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "R02",
      "subject": "security-research",
      "title": "Forge a lab authorization claim",
      "objective": "Separate cryptographic validity from authorization policy using actual Web Crypto and fictional signed capabilities.",
      "unit_id": "research-authority",
      "path": "/security?track=security-research&lab=R02&activity=theory",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "R03",
      "subject": "security-research",
      "title": "Chain stored content with a privileged action",
      "objective": "Reproduce a stored-content chain into a fictional approval action. Repair the rendering and action boundaries independently.",
      "unit_id": "research-authority",
      "path": "/security?track=security-research&lab=R03&activity=theory",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "R04",
      "subject": "security-research",
      "title": "Fuzz a Wasm parser boundary",
      "objective": "Generate bounded inputs against an actual Wasm byte parser, minimize a failing case and repair its validated boundary.",
      "unit_id": "research-evidence",
      "path": "/security?track=security-research&lab=R04&activity=theory",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    },
    {
      "id": "R11",
      "subject": "security-research",
      "title": "Reconstruct an incident from supplied artifacts",
      "objective": "Investigate synthetic event records and write a detection rule that separates unauthorized approval from legitimate activity.",
      "unit_id": "research-evidence",
      "path": "/security?track=security-research&lab=R11&activity=theory",
      "public_teaching": false,
      "plans": ["plus", "pro"]
    }
  ]
}