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

package/lib/testing/logic-args.js

@@ -0,0 +1,229 @@
+/**
+ * Arguments for calling a logic function directly in a unit test.
+ *
+ * Every logic function takes one arguments object, and most of it is the
+ * runtime's to supply: `meta`, the roster, the callbacks, a session summary.
+ * A test cares about the context and perhaps one setting. Each builder here
+ * takes what the test cares about and fills the rest with fixed, deterministic
+ * values, typed so the result passes straight to the function with no cast.
+ *
+ * ```ts
+ * import { logicArgs } from '@seriousgaming/sdk/testing';
+ * import { defaultContext, defaultSettings } from './defaults';
+ * import { Run } from './logic';
+ *
+ * const result = await Run(
+ *     logicArgs.run({ context: defaultContext, settings: defaultSettings, meta: { tick: 3 } })
+ * );
+ * ```
+ *
+ * Settings are not read from disk: there is no runtime here. Pass the
+ * resource's generated `defaultSettings`, spread with any value the test
+ * changes. A resource that declares no settings may leave `settings` out.
+ */
+import { createStubCallbacks } from './stub-services.js';
+/** The `meta.seed` every builder uses unless told otherwise. */
+export const TEST_SEED = 'test-seed';
+/** The `meta.now` every builder uses unless told otherwise: 2026-01-01T00:00:00Z. */
+export const TEST_NOW = Date.UTC(2026, 0, 1);
+function logicMeta(given) {
+    return { locale: 'en', seed: TEST_SEED, runKind: 'session', now: TEST_NOW, ...given };
+}
+function teamRunMeta(given, tick) {
+    const index = given?.index ?? 0;
+    return { ...logicMeta(given), tick, index, teamId: teamIdOf(index), ...given };
+}
+function teamIdOf(index) {
+    return `team-${index + 1}`;
+}
+/** One connected participant on `teamId`, with an id unique across the session. */
+function participantOn(teamId, index) {
+    return { id: String(index + 1), name: 'Participant 1', index: 0, connected: true, teamId };
+}
+function settingsOf(input) {
+    // Absent only where SettingsInput let it be: a TSettings `{}` satisfies.
+    return (input.settings ?? {});
+}
+function callbacksOf(given) {
+    // The stubs are every callback there is, so they satisfy any subset the
+    // resource declares.
+    return { ...createStubCallbacks(), ...given };
+}
+function firstParticipant(participants, teamId) {
+    const participant = participants[0];
+    return participant
+        ? { role: 'participant', participant: { ...participant } }
+        : { role: 'observer', teamId };
+}
+function init(input) {
+    return engineArgs(input, 0);
+}
+function run(input) {
+    return engineArgs(input, 1);
+}
+function engineArgs(input, tick) {
+    const meta = teamRunMeta(input.meta, tick);
+    return {
+        context: input.context,
+        settings: settingsOf(input),
+        meta,
+        participants: input.participants ?? [participantOn(meta.teamId, meta.index)],
+        callbacks: callbacksOf(input.callbacks),
+        ...(input.state === undefined ? {} : { state: input.state }),
+    };
+}
+function aggregate(input) {
+    const teams = input.teams.map((team) => ({
+        ...team,
+        teamId: team.teamId ?? teamIdOf(team.index),
+    }));
+    const given = input;
+    return {
+        // Absent only where the type let it be: a TSharedContext `{}` satisfies.
+        shared: given.shared ?? { context: {} },
+        teams,
+        settings: settingsOf(input),
+        meta: { ...logicMeta(input.meta), tick: 1, ...input.meta },
+        participants: input.participants ?? teams.map((team) => participantOn(team.teamId, team.index)),
+        callbacks: callbacksOf(input.callbacks),
+    };
+}
+function hook(input) {
+    const { signal, meta, participants, callbacks, settings, ...payload } = input;
+    void signal;
+    void settings;
+    const subject = input.participant;
+    const args = {
+        ...payload,
+        settings: settingsOf(input),
+        meta: logicMeta(meta),
+        participants: participants ?? [subject],
+        callbacks: callbacksOf(callbacks),
+    };
+    // `payload` is the signal's payload and `context`, which is what the
+    // compiler cannot see through `HookPayloadMap[S]` with `S` unresolved.
+    return args;
+}
+function endpoint(input) {
+    const index = input.team?.index ?? 0;
+    const team = {
+        teamId: teamIdOf(index),
+        index,
+        name: `Team ${index + 1}`,
+        ...input.team,
+    };
+    const participants = input.participants ?? [participantOn(team.teamId, team.index)];
+    const role = input.caller?.role ?? 'participant';
+    const caller = {
+        ...(role === 'author' ? {} : { sessionId: 'test-session' }),
+        role,
+        ...(role === 'participant' || role === 'observer' ? { teamId: team.teamId } : {}),
+        ...(role === 'participant' && participants[0] ? { playerId: participants[0].id } : {}),
+        ...(role === 'external'
+            ? {}
+            : {
+                userInterfaceIdentifier: role === 'facilitator'
+                    ? 'session'
+                    : role === 'author'
+                        ? 'scenario_editor'
+                        : 'ui',
+            }),
+        ...input.caller,
+    };
+    const session = {
+        mode: 'independent',
+        completedTicks: 0,
+        maxTicks: null,
+        waitingRoomOpen: false,
+        complete: false,
+        teams: [{ ...team, completedTicks: 0, complete: false, timer: null }],
+        ...input.session,
+    };
+    const args = {
+        request: input.request,
+        context: input.context,
+        settings: settingsOf(input),
+        meta: logicMeta(input.meta),
+        participants,
+        callbacks: callbacksOf(input.callbacks),
+        caller,
+        session,
+        // Both halves: a team-scoped handler reads `team`, a session-scoped one
+        // `teams`, and the one a handler's type does not name is never read.
+        team,
+        ...(input.teams === undefined ? {} : { teams: input.teams }),
+    };
+    return args;
+}
+function tickController(input) {
+    const meta = teamRunMeta(input.meta, 1);
+    const teams = input.teams ?? [
+        { teamId: meta.teamId, index: meta.index, context: input.context },
+    ];
+    return {
+        context: input.context,
+        settings: settingsOf(input),
+        meta,
+        participants: input.participants ?? teams.map((team) => participantOn(team.teamId, team.index)),
+        callbacks: callbacksOf(input.callbacks),
+        teams,
+        waitingRoomOpen: input.waitingRoomOpen ?? false,
+    };
+}
+function validator(input) {
+    const participants = input.participants ?? [participantOn('team-1', 0)];
+    return {
+        previous: input.previous,
+        next: input.next,
+        actor: input.actor ?? firstParticipant(participants, 'team-1'),
+        settings: settingsOf(input),
+        meta: logicMeta(input.meta),
+        participants,
+    };
+}
+function requestTick(input) {
+    const participants = input.participants ?? [participantOn('team-1', 0)];
+    return {
+        context: input.context,
+        requestedTick: input.requestedTick ?? 1,
+        actor: input.actor ?? firstParticipant(participants, 'team-1'),
+        settings: settingsOf(input),
+        meta: logicMeta(input.meta),
+        participants,
+    };
+}
+/**
+ * Builders for each logic function's arguments. Each takes what the test
+ * names and fills the rest:
+ *
+ * - `meta`: `locale: 'en'`, `seed: 'test-seed'`, `runKind: 'session'`,
+ *   `now` 2026-01-01T00:00:00Z, and where the function runs for a team,
+ *   `index: 0` and `teamId: 'team-1'`. `tick` is 0 for `init` and 1 for the
+ *   rest; `InitAggregate` passes `meta: { tick: 0 }`
+ * - `participants`: one connected participant on each team the call covers
+ * - `callbacks`: the offline stubs of `createStubCallbacks`, with any the
+ *   test passes in their place
+ * - `settings`: required unless the resource declares none, since there is no
+ *   runtime to resolve them. Pass the generated `defaultSettings`
+ *
+ * | Builder          | For                                             |
+ * | ---------------- | ----------------------------------------------- |
+ * | `init`           | the engine's `Init`                             |
+ * | `run`            | the engine's `Run`, and the steps it calls      |
+ * | `aggregate`      | `RunAggregate` and `InitAggregate`              |
+ * | `hook`           | a hook's `Run`                                  |
+ * | `endpoint`       | an endpoint's `Handle` or `Plan`                |
+ * | `tickController` | `GetTickController`                             |
+ * | `validator`      | a validator's `UpdateData`                      |
+ * | `requestTick`    | a validator's `RequestTick`                     |
+ */
+export const logicArgs = {
+    init,
+    run,
+    aggregate,
+    hook,
+    endpoint,
+    tickController,
+    validator,
+    requestTick,
+};

package/lib/testing/stub-services.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Deterministic, offline stand-ins for the callbacks logic receives.
+ *
+ * A test that reaches the platform fails without a network, without a key and
+ * in a sandbox, and passes or fails on what a model happened to say. These
+ * answer from the request alone, so the same request always gets the same
+ * answer and a test can assert on it.
+ *
+ * One implementation: `createTestSession` in `@seriousgaming/sdk-tools/client`
+ * answers its service callbacks with these too, storing the speech clip in the
+ * session's blob store rather than in memory.
+ */
+import type { LLMGenerateOptions, LLMResponse, ExtractTextResponse, SignatureCallbacks } from '../build/index.js';
+/** How long the stubbed speech clip is, in milliseconds. */
+export declare const STUB_SPEECH_DURATION_MS = 100;
+/**
+ * What a stubbed `generateText` answers for `request`: `[stub <hash>] <excerpt>`,
+ * an eight-digit hex hash of the whole request, then the first 60 characters
+ * of its prompt (the `prompt`, or the last `user` message's text) with
+ * whitespace collapsed, ending in `...` when it was cut. A request with a
+ * `jsonSchema` is answered with JSON that satisfies it.
+ */
+export declare function stubGenerateText(request: LLMGenerateOptions | string): LLMResponse;
+/** What a stubbed `extractText` answers: `[stub] text of <reference>`, without reading the file. */
+export declare function stubExtractText(reference: string): ExtractTextResponse;
+/** The clip a stubbed `generateSpeech` stores: 100ms of 8-bit mono silence, as a WAV file. */
+export declare function stubSpeechAudio(): Uint8Array;
+/**
+ * Every callback logic can receive, stubbed, for calling a logic function
+ * directly in a unit test.
+ *
+ * - `generateText`, `extractText`: {@link stubGenerateText}, {@link stubExtractText}
+ * - `generateSpeech`: stores {@link stubSpeechAudio} and returns its `blob:` reference
+ * - `writeBlob`: stores the bytes and returns `blob:stub-<n>`, numbered from 1
+ * - `readAsset`: reads back a `blob:` reference written here, and rejects
+ *   anything else, naming it, since there is no scenario to read `asset:` from
+ * - `getPastState`: answers `[]`, as a session's first round does
+ *
+ * Blobs live in memory, one store per call, so two tests never share one.
+ */
+export declare function createStubCallbacks(): Required<SignatureCallbacks>;

package/lib/testing/stub-services.js

@@ -0,0 +1,176 @@
+/**
+ * Deterministic, offline stand-ins for the callbacks logic receives.
+ *
+ * A test that reaches the platform fails without a network, without a key and
+ * in a sandbox, and passes or fails on what a model happened to say. These
+ * answer from the request alone, so the same request always gets the same
+ * answer and a test can assert on it.
+ *
+ * One implementation: `createTestSession` in `@seriousgaming/sdk-tools/client`
+ * answers its service callbacks with these too, storing the speech clip in the
+ * session's blob store rather than in memory.
+ */
+/** The longest prompt excerpt a stubbed `generateText` repeats back. */
+const EXCERPT_LENGTH = 60;
+/** How long the stubbed speech clip is, in milliseconds. */
+export const STUB_SPEECH_DURATION_MS = 100;
+const SAMPLE_RATE = 8000;
+/**
+ * What a stubbed `generateText` answers for `request`: `[stub <hash>] <excerpt>`,
+ * an eight-digit hex hash of the whole request, then the first 60 characters
+ * of its prompt (the `prompt`, or the last `user` message's text) with
+ * whitespace collapsed, ending in `...` when it was cut. A request with a
+ * `jsonSchema` is answered with JSON that satisfies it.
+ */
+export function stubGenerateText(request) {
+    const options = typeof request === 'string' ? { prompt: request } : request;
+    const text = options.jsonSchema === undefined
+        ? `[stub ${fnv1a(JSON.stringify(options))}] ${excerpt(promptText(options))}`
+        : JSON.stringify(valueFor(options.jsonSchema));
+    return {
+        content: [{ type: 'text', text }],
+        stopReason: 'endTurn',
+        usage: { inputTokens: 0, outputTokens: 0 },
+    };
+}
+/** What a stubbed `extractText` answers: `[stub] text of <reference>`, without reading the file. */
+export function stubExtractText(reference) {
+    return { content: `[stub] text of ${reference}`, mimeType: 'text/plain' };
+}
+/** The clip a stubbed `generateSpeech` stores: 100ms of 8-bit mono silence, as a WAV file. */
+export function stubSpeechAudio() {
+    const samples = (SAMPLE_RATE * STUB_SPEECH_DURATION_MS) / 1000;
+    const bytes = new Uint8Array(44 + samples);
+    const view = new DataView(bytes.buffer);
+    const ascii = (text, at) => {
+        for (let i = 0; i < text.length; i++)
+            bytes[at + i] = text.charCodeAt(i);
+    };
+    ascii('RIFF', 0);
+    view.setUint32(4, 36 + samples, true);
+    ascii('WAVE', 8);
+    ascii('fmt ', 12);
+    view.setUint32(16, 16, true);
+    view.setUint16(20, 1, true);
+    view.setUint16(22, 1, true);
+    view.setUint32(24, SAMPLE_RATE, true);
+    view.setUint32(28, SAMPLE_RATE, true);
+    view.setUint16(32, 1, true);
+    view.setUint16(34, 8, true);
+    ascii('data', 36);
+    view.setUint32(40, samples, true);
+    // 8-bit PCM is unsigned, so silence is the midpoint rather than zero.
+    bytes.fill(0x80, 44);
+    return bytes;
+}
+/**
+ * Every callback logic can receive, stubbed, for calling a logic function
+ * directly in a unit test.
+ *
+ * - `generateText`, `extractText`: {@link stubGenerateText}, {@link stubExtractText}
+ * - `generateSpeech`: stores {@link stubSpeechAudio} and returns its `blob:` reference
+ * - `writeBlob`: stores the bytes and returns `blob:stub-<n>`, numbered from 1
+ * - `readAsset`: reads back a `blob:` reference written here, and rejects
+ *   anything else, naming it, since there is no scenario to read `asset:` from
+ * - `getPastState`: answers `[]`, as a session's first round does
+ *
+ * Blobs live in memory, one store per call, so two tests never share one.
+ */
+export function createStubCallbacks() {
+    const blobs = new Map();
+    const store = (data, name, mimeType) => {
+        const reference = `blob:stub-${blobs.size + 1}`;
+        blobs.set(reference, { data, name, mimeType });
+        return reference;
+    };
+    return {
+        generateText: async (request) => stubGenerateText(request),
+        extractText: async (reference) => stubExtractText(reference),
+        generateSpeech: async () => {
+            const response = {
+                reference: store(stubSpeechAudio(), 'speech.wav', 'audio/wav'),
+                mimeType: 'audio/wav',
+                durationMs: STUB_SPEECH_DURATION_MS,
+                charactersBilled: 0,
+            };
+            return response;
+        },
+        writeBlob: async (data, options) => store(data instanceof Uint8Array ? data : new Uint8Array(data), options.name, options.mimeType),
+        readAsset: async (reference) => {
+            const blob = blobs.get(reference);
+            if (!blob) {
+                throw new Error(`No stubbed asset "${reference}": only a blob written in this test can be read. ` +
+                    'Pass your own readAsset in callbacks to serve anything else');
+            }
+            return blob;
+        },
+        getPastState: async () => [],
+    };
+}
+function promptText(options) {
+    if (options.prompt !== undefined)
+        return options.prompt;
+    const last = [...(options.messages ?? [])].reverse().find((m) => m.role === 'user');
+    if (!last)
+        return '';
+    if (typeof last.content === 'string')
+        return last.content;
+    return last.content.map((block) => (block.type === 'text' ? block.text : '')).join(' ');
+}
+function excerpt(text) {
+    const collapsed = text.replace(/\s+/g, ' ').trim();
+    return collapsed.length > EXCERPT_LENGTH
+        ? `${collapsed.slice(0, EXCERPT_LENGTH).trimEnd()}...`
+        : collapsed;
+}
+/** 32-bit FNV-1a, as eight hex digits: short, stable and dependency-free. */
+function fnv1a(text) {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < text.length; i++) {
+        hash ^= text.charCodeAt(i);
+        hash = Math.imul(hash, 0x01000193) >>> 0;
+    }
+    return hash.toString(16).padStart(8, '0');
+}
+/**
+ * The smallest value that satisfies `schema`: its `const`, its first `enum`
+ * member or its `default` where it has one, every required property of an
+ * object (every property, when none is required), and the minimum length of
+ * an array.
+ */
+function valueFor(schema) {
+    const loose = schema;
+    if (loose.const !== undefined)
+        return loose.const;
+    if (Array.isArray(schema.enum) && schema.enum.length > 0)
+        return schema.enum[0];
+    if (loose.default !== undefined)
+        return loose.default;
+    const alternative = loose.anyOf?.[0] ?? loose.oneOf?.[0];
+    if (alternative)
+        return valueFor(alternative);
+    const type = Array.isArray(schema.type) ? schema.type[0] : schema.type;
+    switch (type) {
+        case 'object': {
+            const properties = schema.properties ?? {};
+            const keys = schema.required ?? Object.keys(properties);
+            return Object.fromEntries(keys.map((key) => [key, properties[key] ? valueFor(properties[key]) : null]));
+        }
+        case 'array': {
+            const count = loose.minItems ?? 0;
+            const item = schema.items;
+            return Array.from({ length: count }, () => (item ? valueFor(item) : null));
+        }
+        case 'string':
+            return '[stub]';
+        case 'number':
+        case 'integer':
+            return loose.minimum ?? 0;
+        case 'boolean':
+            return false;
+        case 'null':
+            return null;
+        default:
+            return schema.properties ? valueFor({ ...schema, type: 'object' }) : null;
+    }
+}

package/lib/ui/CrossTeamDataContext.d.ts

@@ -0,0 +1,36 @@
+import type { TeamStateEntry } from '../build/callbacks.js';
+export type { TeamStateEntry };
+/**
+ * Every team's live cross-team state, one entry per team, sorted by stable
+ * team index (§5.6) and including the calling team's own.
+ *
+ * Keyed by team rather than by capability, matching what `getPastState`
+ * returns: `entry.context.<capability>` reads the same whether the entry came
+ * from this hook or from a historical read, so one cell renderer serves both.
+ */
+export type CrossTeamData = TeamStateEntry[];
+declare const CrossTeamDataContext: import("react").Context<CrossTeamData | undefined>;
+/**
+ * Observe every team's live cross-team state, including the calling team's
+ * own. Entries update as teams change their pending state, without waiting for
+ * a tick.
+ *
+ * Each entry's `context` carries exactly the capabilities this user interface
+ * declared with `crossTeam: true`, so there is no capability identifier to
+ * pass and none to misspell: pass the generated cross-team context as the type
+ * argument and read fields off it.
+ *
+ * ```typescript
+ * const teams = useUserInterfaceCrossTeamData<Context>();
+ * const total = teams.reduce((sum, team) => sum + team.context.decisions.Price, 0);
+ * ```
+ *
+ * Requires each capability to declare `scope: 'team-readable'` and this
+ * interface to declare the read with `crossTeam: true`. Returns an empty array
+ * until the host delivers the first values.
+ *
+ * The historical counterpart is `getPastState({ teams: 'all' })`, whose entries
+ * are these plus the tick they were captured at.
+ */
+declare function useUserInterfaceCrossTeamData<T = Record<string, unknown>>(): TeamStateEntry<T>[];
+export { useUserInterfaceCrossTeamData, CrossTeamDataContext };

package/lib/ui/CrossTeamDataContext.js

@@ -0,0 +1,32 @@
+import { createContext, useContext } from 'react';
+const CrossTeamDataContext = createContext(undefined);
+/**
+ * Observe every team's live cross-team state, including the calling team's
+ * own. Entries update as teams change their pending state, without waiting for
+ * a tick.
+ *
+ * Each entry's `context` carries exactly the capabilities this user interface
+ * declared with `crossTeam: true`, so there is no capability identifier to
+ * pass and none to misspell: pass the generated cross-team context as the type
+ * argument and read fields off it.
+ *
+ * ```typescript
+ * const teams = useUserInterfaceCrossTeamData<Context>();
+ * const total = teams.reduce((sum, team) => sum + team.context.decisions.Price, 0);
+ * ```
+ *
+ * Requires each capability to declare `scope: 'team-readable'` and this
+ * interface to declare the read with `crossTeam: true`. Returns an empty array
+ * until the host delivers the first values.
+ *
+ * The historical counterpart is `getPastState({ teams: 'all' })`, whose entries
+ * are these plus the tick they were captured at.
+ */
+function useUserInterfaceCrossTeamData() {
+    const ctx = useContext(CrossTeamDataContext);
+    if (!ctx) {
+        throw new Error('useUserInterfaceCrossTeamData must be used inside a UserInterfaceWrapper');
+    }
+    return ctx;
+}
+export { useUserInterfaceCrossTeamData, CrossTeamDataContext };

package/lib/ui/PresentationContext.d.ts

@@ -0,0 +1,72 @@
+import type { PastStateEntry, PastStateQuery } from '../build/callbacks.js';
+import type { SessionMode } from '../build/signatures.js';
+import type { SessionData } from './SessionUserInterfaceDataContext.js';
+import type { TeamInfo } from './SessionUserInterfaceTeamsContext.js';
+import type { SessionUserInterfaceTheme } from './SessionUserInterfaceThemeContext.js';
+import type { UserInterfaceLocale } from './UserInterfaceLocaleContext.js';
+/**
+ * The game a presentation belongs to, as the active scenario resolves it
+ * (§6.15). Known with or without a session.
+ */
+export interface PresentationGame {
+    /** The game's name in the current locale. */
+    name: string;
+    /**
+     * How many rounds it runs for (the `game` settings' `maxTicks`), or `null`
+     * when its engine or tick controller decides.
+     */
+    maxTicks: number | null;
+    mode: SessionMode;
+    /**
+     * The active scenario's display name, or `null` with none. For showing,
+     * never for branching on: a facilitator's own scenario saved from it has a
+     * different identity. Vary a deck on settings and scenario assets instead.
+     */
+    scenarioName: string | null;
+}
+/**
+ * The session a presentation is shown during (§6.15): the shared store and
+ * every team, narrowed to what the presentation `reads`.
+ */
+export interface PresentationSession<TTeamContext = Record<string, unknown>, TSharedContext = Record<string, unknown>> {
+    /**
+     * Stable for the life of the session and unique to it, so a deck can key
+     * anything it remembers by session, such as the slide it was on.
+     */
+    id: string;
+    /** The session's name, as the facilitator sees it. */
+    name: string;
+    /** The most ticks any team has completed; 0 before the first. */
+    completedTicks: number;
+    /** Shared state and each team's state, keyed by team id. */
+    data: SessionData<TTeamContext, TSharedContext>;
+    /** Every team, sorted by index. */
+    teams: TeamInfo[];
+}
+export interface PresentationValue<TSettings, TTeamContext, TSharedContext> {
+    game: PresentationGame;
+    /**
+     * The session it is shown during, or `null` when it is shown with none: in
+     * a game's library, while rehearsing, or to export it beforehand. A deck
+     * MUST render either way, showing sample or placeholder data in place of
+     * results it does not have.
+     */
+    session: PresentationSession<TTeamContext, TSharedContext> | null;
+    /** The settings resources the presentation declares, resolved for the scenario. */
+    settings: TSettings;
+    theme: SessionUserInterfaceTheme;
+    locale: UserInterfaceLocale;
+    /**
+     * Read past rounds (§12.5), as the session UI does. Rejects when there is
+     * no session.
+     */
+    getPastState: <T = Record<string, unknown>>(query: PastStateQuery<T>) => Promise<PastStateEntry<T>[]>;
+    /** Resolve an `asset:`, `shared:` or `blob:` reference to a URL. */
+    getAssetUrl: (reference: string) => string;
+}
+export declare const PresentationContext: import("react").Context<PresentationValue<unknown, unknown, unknown> | undefined>;
+/**
+ * Everything a presentation can see: the session (or `null`), its settings,
+ * the host's theme, and the locale.
+ */
+export declare function usePresentation<TSettings = Record<string, Record<string, unknown>>, TTeamContext = Record<string, unknown>, TSharedContext = Record<string, unknown>>(): PresentationValue<TSettings, TTeamContext, TSharedContext>;

package/lib/ui/PresentationContext.js

@@ -0,0 +1,13 @@
+import { createRequiredContext } from './internal/createContexts.js';
+const { Context, useValue } = createRequiredContext({
+    hookName: 'usePresentation',
+    wrapperName: 'PresentationWrapper',
+});
+export const PresentationContext = Context;
+/**
+ * Everything a presentation can see: the session (or `null`), its settings,
+ * the host's theme, and the locale.
+ */
+export function usePresentation() {
+    return useValue();
+}

package/lib/ui/PresentationWrapper.d.ts

@@ -0,0 +1,12 @@
+import { ReactNode } from 'react';
+interface PresentationWrapperProps {
+    children?: ReactNode;
+    fallback?: ReactNode;
+    targetWindow?: Window;
+}
+/**
+ * Wrap a presentation bundle (§6.15). Read-only: there is nothing here to
+ * write with, and the host would refuse it if there were.
+ */
+export declare function PresentationWrapper({ children, fallback, targetWindow, }: PresentationWrapperProps): import("react").JSX.Element;
+export {};