New signpost to Week 2 and to the Focus on Assessment 1 page that unpacks the brief.

New summary block: four takeaways that mirror the week’s outcomes, so learners can self-check before Week 2.

As you asked, the nine legacy references are deleted and replaced with a single reading list of every article set on pages 1.0 to 1.7, with required readings asterisked and the page each sits on named.

New block carrying the no-generative-AI position in the blueprint’s wording, repeated on the Assessment 1 brief.

The AHRI Model of Excellence is replaced with the 2025 Australian HR Capability Framework, as you asked, and the page text, diagram, accordion and knowledge check are all rebuilt around it.

New watch-out note: if an organisation holds no skills data, that absence is itself a finding for the essay.

The Stovall diversity and inclusion TED talk is removed and replaced with your Honest HR video, embedded to play from the start, with your two questions beneath it.

Padlet retained and embedded as you asked, using the cleaned board. The prompt is repeated in page text with a fallback route for anyone who cannot use Padlet.

New ABLE structure on every task page: challenge, output, task, instructions, then supporting resources. It makes the purpose and the artefact explicit before the learner starts.

New block pointing learners to the help board and the Welcome orientation, so questions have one obvious home.

Proposed synthesia video intro

New for the refresh: the week now opens with a map of all seven pages, their times and the outcome each one builds. From the co-design session, this is the visible scaffolding thread.

Certainly! Let's break down the provided code snippets:

1. What is it and why is it used?

In Mongoose, a schema is a blueprint for defining the structure of documents within a collection. When you define a schema, you can also attach methods to it. These methods become instance methods, meaning they are available on the individual documents (instances) created from that schema.

Instance methods are useful for encapsulating functionality related to a specific document or model instance. They allow you to define custom behavior that can be executed on a specific document. In the given example, the findSimilarTypes method is added to instances of the Animal model, making it easy to find other animals of the same type.

2. Syntax:

Using methods object directly in the schema options:

javascript const animalSchema = new Schema( { name: String, type: String }, { methods: { findSimilarTypes(cb) { return mongoose.model('Animal').find({ type: this.type }, cb); } } } );

Using methods object directly in the schema:

javascript animalSchema.methods.findSimilarTypes = function(cb) { return mongoose.model('Animal').find({ type: this.type }, cb); };

Using Schema.method() helper:

javascript animalSchema.method('findSimilarTypes', function(cb) { return mongoose.model('Animal').find({ type: this.type }, cb); });

3. Explanation in Simple Words with Examples:

Why it's Used:

Imagine you have a collection of animals in your database, and you want to find other animals of the same type. Instead of writing the same logic repeatedly, you can define a method that can be called on each animal instance to find similar types. This helps in keeping your code DRY (Don't Repeat Yourself) and makes it easier to maintain.

Example:

```javascript const mongoose = require('mongoose'); const { Schema } = mongoose;

// Define a schema with a custom instance method const animalSchema = new Schema({ name: String, type: String });

// Add a custom instance method to find similar types animalSchema.methods.findSimilarTypes = function(cb) { return mongoose.model('Animal').find({ type: this.type }, cb); };

// Create the Animal model using the schema const Animal = mongoose.model('Animal', animalSchema);

// Create an instance of Animal const dog = new Animal({ type: 'dog', name: 'Buddy' });

// Use the custom method to find similar types dog.findSimilarTypes((err, similarAnimals) => { console.log(similarAnimals); }); ```

In this example, findSimilarTypes is a custom instance method added to the Animal schema. When you create an instance of the Animal model (e.g., a dog), you can then call findSimilarTypes on that instance to find other animals with the same type. The method uses the this.type property, which refers to the type of the current animal instance. This allows you to easily reuse the logic for finding similar types across different instances of the Animal model.