@seriousgaming/sdk-tools 0.0.0-stage → 1.0.0-alpha.1

package/dist/templates/starter-game/engine/logic.ts

@@ -0,0 +1,149 @@
+import { deriveSeed, InitializationFunction, RunFunction, seededRandom } from '@seriousgaming/sdk';
+
+import type { Context, Settings } from './types';
+
+/**
+ * A day at the lemonade stand.
+ *
+ * The team decides how many of each thing to make before the day starts. Then
+ * people turn up. Anything they made and did not sell is poured away, and they
+ * paid for it either way; anyone who wanted something they had run out of is
+ * turned away, and that is a sale they never see again.
+ *
+ * The whole simulation is that one sentence. Everything below is arithmetic.
+ */
+
+/** The weather for a given day: the same day always gets the same weather. */
+function weatherFor(seed: string, teamIndex: number, day: number): Context['weather']['Today'] {
+    // Derived rather than drawn. An engine function can be invoked more than
+    // once for one logical tick and only the last result is kept, so a live
+    // `Math.random()` would give two runs of the same day different weather and
+    // an author no way to tell which one the team saw.
+    const roll = seededRandom(deriveSeed(seed, teamIndex, 'weather', day))();
+    if (roll < 0.4) return 'sunny';
+    if (roll < 0.75) return 'cloudy';
+    return 'rainy';
+}
+
+const pullFor = (weather: Context['weather']['Today'], settings: Settings) =>
+    weather === 'sunny'
+        ? settings.engine.SunnyPull
+        : weather === 'rainy'
+          ? settings.engine.RainyPull
+          : 1;
+
+/**
+ * How many people want an item on a cloudy day. The menu and the demand are
+ * separate settings, so a scenario can add an item without saying how popular
+ * it is; one it says nothing about has no custom, which shows on the forecast
+ * straight away rather than being quietly made up.
+ */
+const usualDemand = (settings: Settings, id: string) => settings.engine.UsualDemand[id] ?? 0;
+
+/** The forecast a team is shown before a day is played. */
+function forecastFor(settings: Settings, weather: Context['weather']['Today']) {
+    const pull = pullFor(weather, settings);
+    const expected: Record<string, number> = {};
+    for (const id of Object.keys(settings.menu.Menu)) {
+        expected[id] = Math.round(usualDemand(settings, id) * pull);
+    }
+    return expected;
+}
+
+export const Init: InitializationFunction<Context, Settings> = async ({
+    context,
+    settings,
+    meta,
+}) => {
+    const make: Record<string, number> = {};
+    for (const id of Object.keys(settings.menu.Menu)) {
+        // Somewhere to start from, obviously provisional. Starting at nothing
+        // reads as a broken screen; starting at the forecast decides day one
+        // for them.
+        make[id] = Math.round(usualDemand(settings, id) / 2);
+    }
+
+    const weather = weatherFor(meta.seed, meta.index, 1);
+
+    return {
+        capabilities: {
+            ...context,
+            plan: { Make: make },
+            weather: { Today: weather, Expected: forecastFor(settings, weather) },
+            results: {
+                Day: 0,
+                Weather: weather,
+                Lines: {},
+                Takings: 0,
+                Spent: 0,
+                Profit: 0,
+                Purse: 0,
+            },
+        },
+    };
+};
+
+export const Run: RunFunction<Context, Settings> = async ({ context, settings, meta }) => {
+    // `meta.tick` is the tick being executed, so it is today's number
+    // directly. A surface reads `completedTicks` instead, which is the number of
+    // days already finished, and adds one to name the day in play.
+    const day = meta.tick;
+    const weather = weatherFor(meta.seed, meta.index, day);
+    const pull = pullFor(weather, settings);
+
+    // One generator for the day's custom, drawn per item in menu order, so the
+    // same day always plays out the same way.
+    const random = seededRandom(deriveSeed(meta.seed, meta.index, 'custom', day));
+
+    const lines: Context['results']['Lines'] = {};
+    let takings = 0;
+    let spent = 0;
+
+    for (const [id, entry] of sortedMenu(settings)) {
+        const made = Math.max(0, Math.round(context.plan.Make[id] ?? 0));
+        const swing = 1 + (random() * 2 - 1) * settings.engine.Variation;
+        const wanted = Math.max(0, Math.round(usualDemand(settings, id) * pull * swing));
+
+        const sold = Math.min(made, wanted);
+        lines[id] = {
+            Made: made,
+            Wanted: wanted,
+            Sold: sold,
+            PouredAway: made - sold,
+            TurnedAway: wanted - sold,
+        };
+
+        takings += sold * entry.Price;
+        // You paid to make everything, including what you poured away. That is
+        // the whole of the lesson about making too much.
+        spent += made * entry.Cost;
+    }
+
+    const profit = takings - spent;
+    const purse = context.results.Purse + profit;
+
+    // Tomorrow's forecast, so the team has something to decide on before the
+    // next day runs.
+    const tomorrow = weatherFor(meta.seed, meta.index, day + 1);
+
+    return {
+        capabilities: {
+            ...context,
+            weather: { Today: tomorrow, Expected: forecastFor(settings, tomorrow) },
+            results: {
+                Day: day,
+                Weather: weather,
+                Lines: lines,
+                Takings: takings,
+                Spent: spent,
+                Profit: profit,
+                Purse: purse,
+            },
+        },
+    };
+};
+
+/** Menu order, so the day is played and reported in the order it is displayed. */
+function sortedMenu(settings: Settings) {
+    return Object.entries(settings.menu.Menu).sort(([, a], [, b]) => a.Order - b.Order);
+}

package/dist/templates/starter-game/engine/test-helpers.ts

@@ -0,0 +1,74 @@
+import type { TeamRunMeta } from '@seriousgaming/sdk';
+
+import type { Context, Settings } from './types';
+
+/**
+ * Starting fixtures for the engine's tests.
+ *
+ * A test spreads what it cares about over these rather than restating the whole
+ * context, so adding a field to a capability does not break every test that was
+ * never about that field.
+ */
+export const baseSettings: Settings = {
+    menu: {
+        Capacity: 120,
+        Menu: {
+            lemonade: { Name: 'Lemonade', Order: 1, Cost: 15, Price: 50 },
+            icedtea: { Name: 'Iced tea', Order: 2, Cost: 20, Price: 60 },
+            cookies: { Name: 'Cookies', Order: 3, Cost: 25, Price: 70 },
+        },
+    },
+    engine: {
+        UsualDemand: { lemonade: 55, icedtea: 30, cookies: 20 },
+        SunnyPull: 1.3,
+        RainyPull: 0.65,
+        Variation: 0.2,
+    },
+};
+
+export const baseContext: Context = {
+    plan: { Make: { lemonade: 28, icedtea: 15, cookies: 10 } },
+    weather: { Today: 'cloudy', Expected: { lemonade: 55, icedtea: 30, cookies: 20 } },
+    results: {
+        Day: 0,
+        Weather: 'cloudy',
+        Lines: {},
+        Takings: 0,
+        Spent: 0,
+        Profit: 0,
+        Purse: 0,
+    },
+};
+
+/**
+ * The `meta` the runtime supplies. `seed` is fixed, so the weather and the
+ * day's custom are the same every run: this game derives both from it rather
+ * than drawing them, which is what makes a test like this possible at all.
+ */
+export const baseMeta: TeamRunMeta = {
+    tick: 1,
+    locale: 'en',
+    teamId: 'team-1',
+    index: 0,
+    seed: 'lemonade-test-seed',
+    runKind: 'session',
+    now: 0,
+};
+
+/**
+ * The engine declares no `uses`, so every gated callback throws rather than
+ * returning a benign value: a call that reaches one is a declaration bug, and a
+ * test that quietly passes hides it.
+ *
+ * The ungated ones are a different case. They need no declaration, so reaching
+ * one is legitimate, and they answer as a session with nothing in it would.
+ */
+export const callbacks = {
+    generateText: async () => {
+        throw new Error('generateText is not declared by this engine');
+    },
+    readAsset: async () => {
+        throw new Error('readAsset reached, but this engine references no assets');
+    },
+    getPastState: async () => [],
+};

package/dist/templates/starter-game/engine/types.ts

@@ -0,0 +1,139 @@
+// This file is auto-generated from the engine's capability definitions.
+// Do not edit this file directly. It will be regenerated on build.
+
+export interface Context {
+    plan: {
+        /**
+         * How many of each menu item to make today, keyed by item id. Keyed rather than a flat set of fields so that two people changing two different items write different keys, and the host's merge keeps both.
+         */
+        Make: {
+            [k: string]: number;
+        };
+    };
+    weather: {
+        /**
+         * The forecast for the day about to be played
+         */
+        Today: 'sunny' | 'cloudy' | 'rainy';
+        /**
+         * Roughly how many of each item people will want today, keyed by item id. A forecast, not a promise: the day lands somewhere near it.
+         */
+        Expected: {
+            [k: string]: number;
+        };
+    };
+    results: {
+        /**
+         * The day these results are for
+         */
+        Day: number;
+        /**
+         * What the weather actually did
+         */
+        Weather: string;
+        /**
+         * What happened to each menu item, keyed by item id
+         */
+        Lines: {
+            [k: string]: DayLine;
+        };
+        /**
+         * Money in, in pence
+         */
+        Takings: number;
+        /**
+         * Cost of everything made, in pence
+         */
+        Spent: number;
+        /**
+         * Takings less spend, in pence
+         */
+        Profit: number;
+        /**
+         * Everything made so far, in pence
+         */
+        Purse: number;
+    };
+}
+export interface DayLine {
+    Made: number;
+    /**
+     * How many people asked for one
+     */
+    Wanted: number;
+    Sold: number;
+    /**
+     * Made and not sold
+     */
+    PouredAway: number;
+    /**
+     * Asked for and not available
+     */
+    TurnedAway: number;
+}
+
+export type TeamContext = Pick<Context, 'plan' | 'weather' | 'results'>;
+
+export type SharedContext = Record<string, never>;
+
+export interface Settings {
+    menu: {
+        /**
+         * How many items the stall can make in a day, across the whole menu
+         */
+        Capacity: number;
+        Menu: Menu;
+    };
+    engine: {
+        UsualDemand: UsualDemand;
+        /**
+         * How much busier a sunny day is than a cloudy one, as a multiplier on usual demand. 1.3 brings 30% more people
+         */
+        SunnyPull: number;
+        /**
+         * How much quieter a rainy day is than a cloudy one, as a multiplier on usual demand. 0.65 brings 35% fewer people, and above 1 makes rain busier
+         */
+        RainyPull: number;
+        /**
+         * How far a day can land either side of its forecast, as a fraction. 0.2 lands within 20% of it, and 0 makes every forecast exact
+         */
+        Variation: number;
+    };
+}
+/**
+ * What the stall sells, keyed by item id. Money is in pence, so the sums stay in whole numbers. Read by the engine and every surface, so the price on screen and the price in the sums are the same number.
+ */
+export interface Menu {
+    [k: string]: MenuItem;
+}
+export interface MenuItem {
+    /**
+     * What the item is called on every screen
+     */
+    Name: string;
+    /**
+     * Where it sits on the menu, so every screen lists it in the same order. 1 comes first
+     */
+    Order: number;
+    /**
+     * Cost to make one, in pence
+     */
+    Cost: number;
+    /**
+     * Sale price, in pence
+     */
+    Price: number;
+}
+/**
+ * How many people want each menu item on an ordinary cloudy day, keyed by item id. Kept apart from the menu because only the engine reads it: a surface that could see it would be showing the answer. An item on the menu with no entry here has no custom at all, so its forecast reads 0 and nobody buys one.
+ */
+export interface UsualDemand {
+    /**
+     * People a day who want this item when it is cloudy
+     */
+    [k: string]: number;
+}
+
+import type { LogicCallbacks } from '@seriousgaming/sdk';
+
+export type Callbacks = LogicCallbacks;

package/dist/templates/starter-game/guide/content/en/01-at-a-glance.md

@@ -0,0 +1,51 @@
+# Lemonade Stand at a glance
+
+Teams run a lemonade stand for ten days. Each morning they decide how many of each thing to make. Then the day happens.
+
+:::timing
+Total session length: about 50 minutes.
+:::
+
+| Phase    | Duration   | Facilitator focus                                       |
+| -------- | ---------- | ------------------------------------------------------- |
+| Briefing | 5 minutes  | Hand out the stalls and read the one rule               |
+| Play     | 30 minutes | Walk the room while stalls run their own days           |
+| Debrief  | 15 minutes | Connect the two kinds of mistake to the learning points |
+
+## The one rule
+
+Whatever they make in the morning, they have paid for. Anything left at the end of the day is poured away. Anyone who wanted something they had run out of goes home thirsty, and that is a sale they never get back.
+
+That is the whole simulation. There is nothing else to explain.
+
+## The menu
+
+| Item     | Costs to make | Sells for | On an ordinary day       |
+| -------- | ------------- | --------- | ------------------------ |
+| Lemonade | 15p           | 50p       | About 55 people want one |
+| Iced tea | 20p           | 60p       | About 30                 |
+| Cookies  | 25p           | 70p       | About 20                 |
+
+The stall can make 120 things in a day, all told. On a sunny day people want more than that, so a team has to choose what to fill the stall with. Cookies earn the most per item and the fewest people want one.
+
+## What makes it interesting
+
+The forecast tells them roughly what to expect, and the day lands somewhere near it rather than on it. So there is no number that is simply right, and a team that makes exactly the forecast every day still has days it gets wrong.
+
+:::note
+The two mistakes do not feel the same. Pouring lemonade away is visible and annoying; turning people away costs more and leaves nothing behind to look at. Most teams over-correct towards caution after one bad day of waste, and stop noticing the queue they are losing.
+:::
+
+## Two versions
+
+| Scenario         | When to use it                                                                                                        |
+| ---------------- | --------------------------------------------------------------------------------------------------------------------- |
+| An ordinary week | Ten days of mixed weather. The one to run first                                                                       |
+| Heatwave         | Five hot days. Demand is always past what the stall can make, so every day forces a choice about what to fill it with |
+
+Pick one when you create the session.
+
+## Materials
+
+- One laptop or tablet per stall, plus one for you
+- This guide, printed or on a second screen

package/dist/templates/starter-game/guide/content/en/02-preparation.md

@@ -0,0 +1,35 @@
+# Preparation
+
+## Before the room arrives
+
+- Create the session and pick a scenario. An ordinary week is ten days of mixed weather; Heatwave is five hot ones, and every day of it forces a choice. The waiting room opens on its own, so the first person through the door lands on a holding screen rather than in day one
+- Add one stall per group of two to five people. Stalls are independent, so you can add one at any point if a late group arrives
+- Open the session surface on your own screen and leave it there. It is where you can see every stall at once, and where the Observe and Join buttons are
+
+:::tip
+Groups name their own stall from the waiting room. Ask them to do it while you finish the briefing, and your screen stops being a list of 'Team 1' through 'Team 6'.
+:::
+
+## Briefing the room
+
+:::say
+You are running a lemonade stand. Every morning you decide how much lemonade, iced tea and cookies to make. You pay for everything you make. Anything you do not sell gets poured away at the end of the day. Anyone who wants something you have run out of just leaves. When your stall is ready, you open it yourselves and the day happens. Ten days. Most money in the jar wins.
+:::
+
+:::do
+Do not explain the weather, the capacity, or the margins. All three are on the screen, and a stall that discovers the cookies earn the most has learned something a stall that was told has not.
+:::
+
+## Who does what
+
+As people join, the game puts each of them in charge of one thing on the menu. A stall of three gets one person each on lemonade, iced tea and cookies; a stall of five gets two people on the lemonade.
+
+Nobody is stopped from changing somebody else's item. The point of handing them out is that in ordinary play three people work on three different things at once and nothing gets in anyone's way.
+
+:::note
+There is one thing they share: the stall can only make 120 things a day. If two people each add to their own item at the same moment and the total goes over, the second change is refused and says so. It is worth watching for: a team that hits it once usually starts talking to each other properly.
+:::
+
+## Opening up
+
+Close the waiting room when every stall is named and settled. Every player's screen swaps to the game without a reload, and nothing about the session changes, so you can reopen it mid-session for a discussion and pick up exactly where the stalls were.

package/dist/templates/starter-game/guide/content/en/03-running-the-day.md

@@ -0,0 +1,58 @@
+# Running the day
+
+## The shape of a day
+
+1. The stall reads the forecast and sets its numbers
+2. The stall presses Open the stall, and the day plays out
+3. The stall reads what happened and changes its mind about tomorrow
+
+**The stalls run their own days.** Each one moves at its own pace, and nobody waits for the room. You are not driving the session, which means you are free to walk around it.
+
+:::do
+The Today column on your screen says which stalls have changed their numbers since the day they last traded. There is no 'ready' button anywhere, so this is what tells you who is thinking and who has stopped. A stall showing 'Same as yesterday' has either decided to repeat itself or forgotten to look.
+:::
+
+:::note
+A fast group will be on day six while a slow one is on day two. That is fine, and it is worth saying so at the briefing, or the fast group will think they have broken something. Pull the room together for the debrief rather than trying to keep it in step.
+:::
+
+## Getting into a stall
+
+Every row has two ways in.
+
+- **Observe** opens that stall's screen exactly as they see it, without joining. Nobody appears on their roster and nothing changes. This is the one to use when you are checking on a quiet group
+- **Join** puts you on the stall as a player, which is what you want when you are showing somebody how something works
+- **Copy link** gives you the join link to hand out, for a latecomer or a slide
+
+**Undo** is the one thing that only you can do. If a stall opens up before it meant to, take the day back and let them try again.
+
+## What to listen for
+
+| Day     | What usually happens                                           | Worth asking                                        |
+| ------- | -------------------------------------------------------------- | --------------------------------------------------- |
+| 1       | Stalls make roughly the forecast, or roughly nothing           | 'How much of that did you actually sell?'           |
+| 2 to 3  | A sunny day catches them out and they hit the capacity limit   | 'You could not make everything. What did you drop?' |
+| 4 to 6  | They over-correct after a day of pouring lemonade away         | 'How many people went home without one?'            |
+| 7 to 10 | The gap between the stalls that kept adjusting becomes obvious | 'When did you last change your numbers, and why?'   |
+
+## Two things participants ask
+
+**'Why did my change get refused?'** Somebody else on the stall was changing their own item at the same moment, and together the two changes asked for more than the stall can make. The screen says so. They take some off something and try again.
+
+**'Can I change somebody else's item?'** Yes. The game hands out the menu so that three people can work at once without treading on each other, not to stop anyone.
+
+**'Somebody opened the stall before I was ready.'** Anyone on the stall can open it, and their change counts for the day that just ran. If a number was still being moved when it happened, the screen says the change counts for the next day instead. Ask them to sort out who says go.
+
+## Debrief
+
+The mechanical answer is that you cannot know the day in advance, so you are choosing which mistake to make.
+
+The conversation worth having is underneath that.
+
+- Which mistake did your stall prefer, and did you ever say so out loud?
+- Pouring lemonade away is right there on the screen. The people who went home are a number you have to go looking for. Which one drove your decisions?
+- What did the capacity limit make you give up, and was it the right thing?
+
+:::note
+If nobody raises it, show a stall the Turned away column for a good day and a bad one side by side. Most teams have never added it up.
+:::

package/dist/templates/starter-game/guide/guide.sdk.json

@@ -0,0 +1,10 @@
+{
+    "definition": {
+        "locales": {
+            "en": {
+                "name": "Facilitator guide"
+            }
+        }
+    },
+    "rootDirectory": "."
+}

package/dist/templates/starter-game/guide/guide.test.ts

@@ -0,0 +1,108 @@
+// @vitest-environment node
+
+/**
+ * Structural tests for the facilitator guide.
+ *
+ * A guide is content, not code, so these guard the contract the host relies on
+ * rather than anything it says: it sits where the package will find it, every
+ * declared locale carries the same chapters, every admonition is one the
+ * renderer knows, and every image reference resolves. `pnpm run sdk build --
+ * --validate-only` runs the same checks at build time; this keeps them in the
+ * package's own test loop.
+ */
+
+import { existsSync, readdirSync, readFileSync } from 'fs';
+import { dirname, join, resolve } from 'path';
+import { fileURLToPath } from 'url';
+
+import { describe, expect, it } from 'vitest';
+
+const GUIDE_DIR = fileURLToPath(new URL('.', import.meta.url));
+const PACKAGE_DIR = resolve(GUIDE_DIR, '..');
+
+/** The six the renderer defines. Anything else renders as an inert error block. */
+const ADMONITIONS = ['note', 'warning', 'tip', 'say', 'do', 'timing'];
+
+const bundle = JSON.parse(readFileSync(join(GUIDE_DIR, 'guide.sdk.json'), 'utf-8'));
+const declaredLocales: string[] = Object.keys(bundle.definition.locales);
+
+const chapters = (locale: string) =>
+    readdirSync(join(GUIDE_DIR, 'content', locale))
+        .filter((name) => name.endsWith('.md'))
+        .sort();
+
+const chapterFiles = () =>
+    declaredLocales.flatMap((locale) =>
+        chapters(locale).map((file) => ({
+            locale,
+            file,
+            content: readFileSync(join(GUIDE_DIR, 'content', locale, file), 'utf-8'),
+        }))
+    );
+
+describe('the bundle', () => {
+    it('sits in the slot the package scans', () => {
+        expect(existsSync(join(PACKAGE_DIR, 'guide', 'guide.sdk.json'))).toBe(true);
+    });
+
+    it('carries no identifier of its own, because the slot names it', () => {
+        expect(bundle.definition.identifier).toBeUndefined();
+    });
+
+    it('names itself in every declared locale', () => {
+        expect(declaredLocales.length).toBeGreaterThan(0);
+        for (const locale of declaredLocales) {
+            expect(bundle.definition.locales[locale].name).toBeTruthy();
+        }
+    });
+});
+
+describe('the content', () => {
+    it('mirrors the same chapter file set across every declared locale', () => {
+        const [reference, ...rest] = declaredLocales;
+        const referenceChapters = chapters(reference as string);
+        expect(referenceChapters.length).toBeGreaterThan(0);
+        for (const locale of rest) {
+            expect(chapters(locale)).toEqual(referenceChapters);
+        }
+    });
+
+    it('opens every chapter with a heading, which is what the contents list', () => {
+        for (const { locale, file, content } of chapterFiles()) {
+            expect(content.startsWith('# '), `${locale}/${file}`).toBe(true);
+        }
+    });
+
+    it('uses only admonitions the renderer defines', () => {
+        for (const { locale, file, content } of chapterFiles()) {
+            for (const match of content.matchAll(/^:::(\w+)/gm)) {
+                expect(ADMONITIONS, `${locale}/${file}`).toContain(match[1]);
+            }
+        }
+    });
+
+    it('closes every admonition it opens', () => {
+        for (const { locale, file, content } of chapterFiles()) {
+            const markers = content.match(/^:::/gm) ?? [];
+            expect(markers.length % 2, `${locale}/${file}`).toBe(0);
+        }
+    });
+
+    it('references only images that exist inside the guide directory', () => {
+        for (const { locale, file, content } of chapterFiles()) {
+            for (const match of content.matchAll(/!\[[^\]]*\]\(([^()\s]+)\)/g)) {
+                const target = match[1] as string;
+                if (/^[a-z][a-z0-9+.-]*:/i.test(target) || target.startsWith('/')) continue;
+                const resolved = resolve(dirname(join(GUIDE_DIR, 'content', locale, file)), target);
+                expect(
+                    resolved.startsWith(resolve(GUIDE_DIR)),
+                    `${locale}/${file}: ${target} escapes the guide directory`
+                ).toBe(true);
+                expect(
+                    existsSync(resolved),
+                    `${locale}/${file}: ${target} does not resolve to a file`
+                ).toBe(true);
+            }
+        }
+    });
+});

package/dist/templates/starter-game/hooks/assignproducts/defaults.ts

@@ -0,0 +1,37 @@
+// This file is auto-generated from the schemas the resource declares: the values
+// a session starts with, for use as test fixtures.
+// Do not edit this file directly. It will be regenerated on build.
+
+import type { Context, Settings } from './types';
+
+export const defaultContext: Context = {
+    roles: {
+        LooksAfter: {},
+    },
+};
+
+export const defaultSettings: Settings = {
+    menu: {
+        Capacity: 120,
+        Menu: {
+            lemonade: {
+                Name: 'Lemonade',
+                Order: 1,
+                Cost: 15,
+                Price: 50,
+            },
+            icedtea: {
+                Name: 'Iced tea',
+                Order: 2,
+                Cost: 20,
+                Price: 60,
+            },
+            cookies: {
+                Name: 'Cookies',
+                Order: 3,
+                Cost: 25,
+                Price: 70,
+            },
+        },
+    },
+};

package/dist/templates/starter-game/hooks/assignproducts/hook.sdk.json

@@ -0,0 +1,13 @@
+{
+    "definition": {
+        "signal": "participantJoin",
+        "reads": ["roles"],
+        "writes": ["roles"],
+        "settings": ["menu"]
+    },
+    "logic": {
+        "directory": "logic",
+        "entrypoint": "logic.ts"
+    },
+    "rootDirectory": "."
+}