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

package/dist/templates/ui/src/i18n.ts.liquid

@@ -0,0 +1,47 @@
+import i18n from 'i18next';
+import { initReactI18next } from 'react-i18next';
+
+// Translation resources
+const resources = {
+    en: {
+        translation: {
+            greeting: 'Hello, World!',
+            welcomeMessage: 'Welcome to your Serious Gaming User Interface.',
+            dataExample:
+                "The component below demonstrates reading and writing data to the game's shared state by using a capability.",
+            currentValue: 'Current value: {% raw %}{{value}}{% endraw %}',
+            updateButton: 'Increment Value',
+        },
+    },
+    it: {
+        translation: {
+            greeting: 'Ciao, mondo!',
+            welcomeMessage: 'Benvenuto nella tua interfaccia utente di Serious Gaming.',
+            dataExample:
+                'Il componente sottostante dimostra come leggere e scrivere dati nello stato condiviso della simulazione utilizzando una capability.',
+            currentValue: 'Valore corrente: {% raw %}{{value}}{% endraw %}',
+            updateButton: 'Incrementa valore',
+        },
+    },
+    ar: {
+        translation: {
+            greeting: 'أهلاً بالعالم!',
+            welcomeMessage: 'مرحبًا بك في واجهة مستخدم كونشيرتو الخاصة بك.',
+            dataExample:
+                'يوضح المكون أدناه قراءة البيانات وكتابتها إلى الحالة المشتركة للمحاكاة باستخدام إحدى الإمكانات.',
+            currentValue: 'القيمة الحالية: {% raw %}{{value}}{% endraw %}',
+            updateButton: 'زيادة القيمة',
+        },
+    },
+};
+
+i18n.use(initReactI18next).init({
+    resources,
+    lng: 'en', // default language
+    fallbackLng: 'en',
+    interpolation: {
+        escapeValue: false, // React already escapes
+    },
+});
+
+export default i18n;

package/dist/templates/ui/src/main.tsx.liquid

@@ -0,0 +1,48 @@
+import createCache from '@emotion/cache';
+import { CacheProvider } from '@emotion/react';
+import '@fontsource-variable/roboto-mono';
+import '@fontsource-variable/work-sans';
+import rtlPlugin from '@mui/stylis-plugin-rtl';
+import { UserInterfaceWrapper, useUserInterfaceLocale } from '@seriousgaming/sdk/ui';
+
+import './i18n';
+import i18n from 'i18next';
+import React, { StrictMode, useEffect } from 'react';
+import { createRoot } from 'react-dom/client';
+import { prefixer } from 'stylis';
+
+import App from './App';
+
+// Create RTL cache
+const cacheRtl = createCache({
+    key: 'muirtl',
+    stylisPlugins: [prefixer, rtlPlugin],
+});
+
+const cacheLtr = createCache({
+    key: 'muiltr',
+});
+
+// Wrapper component to sync locale with i18next and setup RTL
+function RootWrapper({ children }: { children: React.ReactNode }) {
+    const { locale } = useUserInterfaceLocale();
+
+    useEffect(() => {
+        const i18nextLocale = locale.split('-')[0];
+        i18n.changeLanguage(i18nextLocale);
+    }, [locale]);
+
+    const isRtl = i18n.dir(locale.split('-')[0]) === 'rtl';
+
+    return <CacheProvider value={isRtl ? cacheRtl : cacheLtr}>{children}</CacheProvider>;
+}
+
+createRoot(document.getElementById('root')!).render(
+    <StrictMode>
+        <UserInterfaceWrapper>
+            <RootWrapper>
+                <App />
+            </RootWrapper>
+        </UserInterfaceWrapper>
+    </StrictMode>
+);

package/dist/templates/ui/src/theme.ts.liquid

@@ -0,0 +1,46 @@
+{% raw %}import { createTheme } from '@mui/material/styles';
+import { useUserInterfaceTheme } from '@seriousgaming/sdk/ui';
+import { useMemo } from 'react';
+
+/**
+ * The host owns the palette, the game owns the typography and the component
+ * shapes. Reading `theme.mode` rather than the browser's preference is what
+ * keeps a participant's screen and the facilitator's looking like one product.
+ */
+export const useAppTheme = () => {
+    const theme = useUserInterfaceTheme();
+
+    return useMemo(() => {
+        const colors = theme.mode === 'light' ? theme.light : theme.dark;
+        return createTheme({
+            palette: {
+                mode: theme.mode,
+                primary: { main: colors.primary, contrastText: colors.contrastText.primary },
+                secondary: { main: colors.secondary, contrastText: colors.contrastText.secondary },
+                success: { main: colors.success, contrastText: colors.contrastText.success },
+                error: { main: colors.error, contrastText: colors.contrastText.error },
+                warning: { main: colors.warning, contrastText: colors.contrastText.warning },
+                info: { main: colors.info, contrastText: colors.contrastText.info },
+            },
+            shape: { borderRadius: 10 },
+            components: {
+                MuiButton: { styleOverrides: { root: { textTransform: 'none' } } },
+                MuiTab: {
+                    styleOverrides: { root: { textTransform: 'none', fontSize: '0.95rem' } },
+                },
+                MuiToggleButton: { styleOverrides: { root: { textTransform: 'none' } } },
+                MuiTableCell: {
+                    styleOverrides: {
+                        head: {
+                            fontSize: '0.75rem',
+                            fontWeight: 700,
+                            letterSpacing: '0.07em',
+                            textTransform: 'uppercase',
+                        },
+                    },
+                },
+            },
+        });
+    }, [theme]);
+};
+{% endraw %}

package/dist/templates/validator/logic.test.ts.liquid

@@ -0,0 +1,42 @@
+import { describe, it, expect } from 'vitest';
+import { UpdateData } from './logic';
+import type { Context, Settings } from '../types';
+import type { LogicMeta } from '@seriousgaming/sdk';
+
+// The run-wide facts the host supplies: the session locale, its random seed,
+// whether this is the game being played or a walkthrough beside it, and when
+// the operation started.
+const meta: LogicMeta = { locale: 'en', seed: 'test-seed', runKind: 'session', now: Date.UTC(2026, 0, 1) };
+
+// Who submitted the mutation. Swap for `{ role: 'observer', teamId: 'team-1' }`
+// to cover a facilitator observing the team on the same surface.
+const actor = {
+    role: 'participant',
+    participant: {
+        id: '1',
+        teamId: 'team-1',
+        name: 'Participant 1',
+        index: 0,
+        connected: true,
+    },
+} as const;
+
+describe('{{ identifier }}', () => {
+  describe('UpdateData', () => {
+    it('accepts a valid mutation', async () => {
+      const previous: Context = {
+        // TODO: Add context values based on required capabilities
+      } as Context;
+      const next: Context = {
+        // TODO: Add proposed next-state values
+      } as Context;
+      const settings: Settings = {
+        // TODO: Add values for the settings resources this reads
+      } as Settings;
+
+      const result = await UpdateData({ previous, next, actor, settings, meta, participants: [actor.participant] });
+
+      expect(result.ok).toBe(true);
+    });
+  });
+});

package/dist/templates/validator/logic.ts.liquid

@@ -0,0 +1,21 @@
+import type { ValidatorFunction } from '../types';
+
+// A validator gates what a participant does, one export per action. This one
+// is `UpdateData`, the gate on a context write. Export `RequestTick` as well
+// (typed `RequestTickFunction` from '../types') to gate a participant's request
+// for the next tick: it receives `{ context, requestedTick, actor, settings, meta }`.
+export const UpdateData: ValidatorFunction = async ({ previous, next, actor, settings }) => {
+  // Validators gate UI-submitted mutations before they're applied.
+  // Return { ok: true } to allow, { ok: false, message: '...' } to reject.
+  // The proposed `next` state is what would be applied if every referenced
+  // validator returns ok.
+  //
+  // `actor` says who submitted it: a participant, or a facilitator observing
+  // the team on the same surface. Both are held to this rule unless you say
+  // otherwise, e.g.:
+  //
+  //   if (actor.role === 'observer') return { ok: true };
+  //
+  // Narrow on `actor.role` before reading `actor.participant`.
+  return { ok: true };
+};

package/dist/templates/waiting-room/index.html.liquid

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>{{ name }}</title>
+    </head>
+    <body>
+        <div id="root"></div>
+        <script type="module" src="./src/main.tsx"></script>
+    </body>
+</html>

package/dist/templates/waiting-room/src/App.test.tsx.liquid

@@ -0,0 +1,57 @@
+{% raw %}import { describe, it, expect, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import {
+    UserInterfaceDataContext,
+    UserInterfaceOwnTeamContext,
+    UserInterfaceParticipantContext,
+    UserInterfaceParticipantsContext,
+    UserInterfaceThemeContext,
+} from '@seriousgaming/sdk/ui';
+import { createMockTheme } from '@seriousgaming/sdk/ui/testing';
+import './i18n';
+import App from './App';
+
+// A waiting room UI is a player UI, so it renders under the same context
+// providers. These replace the iframe communication the real app uses.
+const SELF = { id: 'p1', name: 'Ada', index: 0, connected: true, teamId: 'team-1' };
+const ROSTER = [
+    { ...SELF, connected: true },
+    { id: 'p2', name: 'Grace', index: 1, teamId: 'team-1', connected: false },
+];
+
+const renderApp = (completedTicks = 0) =>
+    render(
+        <UserInterfaceThemeContext.Provider value={createMockTheme()}>
+            <UserInterfaceDataContext.Provider
+                value={{ data: {}, settings: {}, completedTicks, isRoundProcessing: false, setData: vi.fn() }}
+            >
+                <UserInterfaceOwnTeamContext.Provider
+                    value={{ teamId: 'team-1', index: 0, name: 'Team 1' }}
+                >
+                    <UserInterfaceParticipantContext.Provider value={SELF}>
+                        <UserInterfaceParticipantsContext.Provider value={ROSTER}>
+                            <App />
+                        </UserInterfaceParticipantsContext.Provider>
+                    </UserInterfaceParticipantContext.Provider>
+                </UserInterfaceOwnTeamContext.Provider>
+            </UserInterfaceDataContext.Provider>
+        </UserInterfaceThemeContext.Provider>
+    );
+
+describe('App', () => {
+    it('says the session has not begun at tick 0', () => {
+        renderApp(0);
+        expect(screen.getByText(/waiting to begin/i)).toBeInTheDocument();
+    });
+
+    it('says the session is paused once ticks have run', () => {
+        renderApp(3);
+        expect(screen.getByText(/session paused/i)).toBeInTheDocument();
+    });
+
+    it('lists the team roster and marks the reader', () => {
+        renderApp();
+        expect(screen.getByText(/ada \(you\)/i)).toBeInTheDocument();
+        expect(screen.getByText('Grace')).toBeInTheDocument();
+    });
+});{% endraw %}

package/dist/templates/waiting-room/src/App.tsx.liquid

@@ -0,0 +1,118 @@
+{% raw %}import React from 'react';
+import { Box, CssBaseline, ThemeProvider, Typography } from '@mui/material';
+import {
+    useUserInterfaceOwnTeam,
+    useUserInterfaceData,
+    useUserInterfaceParticipant,
+    useUserInterfaceParticipants,
+} from '@seriousgaming/sdk/ui';
+import { useTranslation } from 'react-i18next';
+import { Context, Settings } from '../types';
+import { useAppTheme } from './theme';
+
+/*
+This UI requires the following dependencies:
+- @mui/material
+- @emotion/react
+- @emotion/styled
+- stylis
+- @mui/stylis-plugin-rtl
+- @fontsource-variable/roboto-mono
+- @fontsource-variable/work-sans
+- i18next
+- react-i18next
+
+Make sure to install them in your project, e.g.:
+pnpm add @mui/material @emotion/react @emotion/styled stylis @mui/stylis-plugin-rtl @fontsource-variable/roboto-mono @fontsource-variable/work-sans i18next react-i18next
+*/
+
+/*
+A waiting room user interface is a player user interface shown in a different
+place: the host mounts it instead of the game UIs while the facilitator has the
+session's waiting room open, and swaps back the moment they close it. Every
+player hook and callback works here exactly as it does in a game UI, so this
+file uses `useUserInterfaceData` and friends rather than a waiting-room-specific
+API.
+
+Two things are worth knowing while you build one:
+
+1. The room can be opened at any point, not only before the session starts. Read
+   `completedTicks` to tell the two apart — 0 means the session has not begun,
+   anything higher means the facilitator has parked a session already in play.
+2. Opening the room does not stop the clock. If you want automatic ticks to
+   pause while players wait, read `waitingRoomOpen` in your tick controller and
+   return `enabled: false`.
+*/
+
+function App() {
+    const { completedTicks } = useUserInterfaceData<Context, Settings>();
+    const { t } = useTranslation();
+    const theme = useAppTheme();
+    const ownTeam = useUserInterfaceOwnTeam();
+    const participants = useUserInterfaceParticipants();
+    const self = useUserInterfaceParticipant();
+
+    const roster = [...participants].sort((a, b) => a.index - b.index);
+
+    return (
+        <ThemeProvider theme={theme}>
+            <CssBaseline enableColorScheme />
+            <Box
+                sx={{
+                    display: 'flex',
+                    flexDirection: 'column',
+                    alignItems: 'center',
+                    justifyContent: 'center',
+                    gap: 2,
+                    minHeight: '100vh',
+                    p: 3,
+                    textAlign: 'center',
+                }}
+            >
+                <Typography variant="h4" component="h1">
+                    {completedTicks === 0 ? t('headingBeforeStart') : t('headingPaused')}
+                </Typography>
+
+                <Typography variant="body1" color="text.secondary">
+                    {ownTeam
+                        ? t('joinedTeam', { team: ownTeam.name })
+                        : t('waitingForFacilitator')}
+                </Typography>
+
+                <Box component="ul" sx={{ listStyle: 'none', p: 0, m: 0 }}>
+                    {roster.map((participant) => (
+                        <Box
+                            component="li"
+                            key={participant.id}
+                            sx={{
+                                display: 'flex',
+                                alignItems: 'center',
+                                justifyContent: 'center',
+                                gap: 1,
+                            }}
+                        >
+                            <Box
+                                aria-hidden
+                                sx={{
+                                    width: 8,
+                                    height: 8,
+                                    borderRadius: '50%',
+                                    bgcolor: participant.connected
+                                        ? 'success.main'
+                                        : 'text.disabled',
+                                }}
+                            />
+                            <Typography variant="body2">
+                                {participant.id === self?.id
+                                    ? t('participantSelf', { name: participant.name })
+                                    : participant.name}
+                            </Typography>
+                        </Box>
+                    ))}
+                </Box>
+            </Box>
+        </ThemeProvider>
+    );
+}
+
+export default App;{% endraw %}

package/dist/templates/waiting-room/src/i18n.ts.liquid

@@ -0,0 +1,44 @@
+import i18n from 'i18next';
+import { initReactI18next } from 'react-i18next';
+
+// Translation resources
+const resources = {
+    en: {
+        translation: {
+            headingBeforeStart: 'Waiting to begin',
+            headingPaused: 'Session paused',
+            joinedTeam: "You've joined {% raw %}{{team}}{% endraw %}. The facilitator will continue shortly.",
+            waitingForFacilitator: 'The facilitator will continue shortly.',
+            participantSelf: '{% raw %}{{name}}{% endraw %} (you)',
+        },
+    },
+    it: {
+        translation: {
+            headingBeforeStart: 'In attesa di iniziare',
+            headingPaused: 'Sessione in pausa',
+            joinedTeam: 'Ti sei unito a {% raw %}{{team}}{% endraw %}. Il facilitatore proseguirà a breve.',
+            waitingForFacilitator: 'Il facilitatore proseguirà a breve.',
+            participantSelf: '{% raw %}{{name}}{% endraw %} (tu)',
+        },
+    },
+    ar: {
+        translation: {
+            headingBeforeStart: 'في انتظار البدء',
+            headingPaused: 'الجلسة متوقفة مؤقتًا',
+            joinedTeam: 'لقد انضممت إلى {% raw %}{{team}}{% endraw %}. سيتابع الميسر قريبًا.',
+            waitingForFacilitator: 'سيتابع الميسر قريبًا.',
+            participantSelf: '{% raw %}{{name}}{% endraw %} (أنت)',
+        },
+    },
+};
+
+i18n.use(initReactI18next).init({
+    resources,
+    lng: 'en', // default language
+    fallbackLng: 'en',
+    interpolation: {
+        escapeValue: false, // React already escapes
+    },
+});
+
+export default i18n;

package/dist/templates/waiting-room/src/main.tsx.liquid

@@ -0,0 +1,48 @@
+import createCache from '@emotion/cache';
+import { CacheProvider } from '@emotion/react';
+import '@fontsource-variable/roboto-mono';
+import '@fontsource-variable/work-sans';
+import rtlPlugin from '@mui/stylis-plugin-rtl';
+import { UserInterfaceWrapper, useUserInterfaceLocale } from '@seriousgaming/sdk/ui';
+
+import './i18n';
+import i18n from 'i18next';
+import React, { StrictMode, useEffect } from 'react';
+import { createRoot } from 'react-dom/client';
+import { prefixer } from 'stylis';
+
+import App from './App';
+
+// Create RTL cache
+const cacheRtl = createCache({
+    key: 'muirtl',
+    stylisPlugins: [prefixer, rtlPlugin],
+});
+
+const cacheLtr = createCache({
+    key: 'muiltr',
+});
+
+// Wrapper component to sync locale with i18next and setup RTL
+function RootWrapper({ children }: { children: React.ReactNode }) {
+    const { locale } = useUserInterfaceLocale();
+
+    useEffect(() => {
+        const i18nextLocale = locale.split('-')[0];
+        i18n.changeLanguage(i18nextLocale);
+    }, [locale]);
+
+    const isRtl = i18n.dir(locale.split('-')[0]) === 'rtl';
+
+    return <CacheProvider value={isRtl ? cacheRtl : cacheLtr}>{children}</CacheProvider>;
+}
+
+createRoot(document.getElementById('root')!).render(
+    <StrictMode>
+        <UserInterfaceWrapper>
+            <RootWrapper>
+                <App />
+            </RootWrapper>
+        </UserInterfaceWrapper>
+    </StrictMode>
+);

package/dist/templates/waiting-room/src/theme.ts.liquid

@@ -0,0 +1,46 @@
+{% raw %}import { createTheme } from '@mui/material/styles';
+import { useUserInterfaceTheme } from '@seriousgaming/sdk/ui';
+import { useMemo } from 'react';
+
+/**
+ * The host owns the palette, the game owns the typography and the component
+ * shapes. Reading `theme.mode` rather than the browser's preference is what
+ * keeps a participant's screen and the facilitator's looking like one product.
+ */
+export const useAppTheme = () => {
+    const theme = useUserInterfaceTheme();
+
+    return useMemo(() => {
+        const colors = theme.mode === 'light' ? theme.light : theme.dark;
+        return createTheme({
+            palette: {
+                mode: theme.mode,
+                primary: { main: colors.primary, contrastText: colors.contrastText.primary },
+                secondary: { main: colors.secondary, contrastText: colors.contrastText.secondary },
+                success: { main: colors.success, contrastText: colors.contrastText.success },
+                error: { main: colors.error, contrastText: colors.contrastText.error },
+                warning: { main: colors.warning, contrastText: colors.contrastText.warning },
+                info: { main: colors.info, contrastText: colors.contrastText.info },
+            },
+            shape: { borderRadius: 10 },
+            components: {
+                MuiButton: { styleOverrides: { root: { textTransform: 'none' } } },
+                MuiTab: {
+                    styleOverrides: { root: { textTransform: 'none', fontSize: '0.95rem' } },
+                },
+                MuiToggleButton: { styleOverrides: { root: { textTransform: 'none' } } },
+                MuiTableCell: {
+                    styleOverrides: {
+                        head: {
+                            fontSize: '0.75rem',
+                            fontWeight: 700,
+                            letterSpacing: '0.07em',
+                            textTransform: 'uppercase',
+                        },
+                    },
+                },
+            },
+        });
+    }, [theme]);
+};
+{% endraw %}

package/dist/templating/resource-metadata.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Resource metadata registry — the single source of truth for how each resource
+ * type is laid out on disk and how it is referenced by other resources.
+ *
+ * Before #282 every `templating/<type>.ts` file hand-copied the same
+ * create/update/delete/find/update-references skeleton, so a bug in the shared
+ * idiom had to be fixed 15 times and each type's reference coverage drifted
+ * independently (capability delete only scanned the engine and UIs;
+ * scenario/facilitator-guide renames orphaned their references). The generic
+ * engine in `engine.ts` reads this registry so every type applies the same,
+ * complete rewriting.
+ */
+/**
+ * How references to a resource appear inside a referrer's `definition`.
+ *
+ * - `stringArray`  — `definition[path]: string[]` of identifiers. An optional
+ *   `labelSuffix` tags the reference label ('reads' / 'writes' /
+ *   'crossTeamReads' for the capability fan-out).
+ * - `keyedMap`     — `definition[path]: Record<identifier, {...}>`; the
+ *   identifier is the key, so a rename re-keys and a delete drops the entry.
+ *   A scenario's `settings` is one, keyed by settings identifier.
+ */
+export type ReferenceShape = {
+    kind: 'stringArray';
+    path: string;
+    labelSuffix?: string;
+} | {
+    kind: 'keyedMap';
+    path: string;
+};
+/**
+ * The referrer key standing for the manifest itself rather than a list of
+ * bundle files. A package is a game (#421), so the settings that reference
+ * resources by identifier sit at the manifest's top level.
+ */
+export declare const MANIFEST_REFERRER = "__manifest__";
+/** One place a resource type is referenced: which referrer files, and how. */
+export interface ReferenceSite {
+    /**
+     * Manifest keys (in seriousgaming.sdk.json) of the referrer files to scan,
+     * or {@link MANIFEST_REFERRER} for the manifest itself.
+     */
+    referrerKeys: string[];
+    shape: ReferenceShape;
+}
+export type ResourceKind = 'logic' | 'ui' | 'composition' | 'content';
+/** Every registered resource type, so a stale type name is a compile error. */
+export declare const RESOURCE_TYPES: readonly ["capability", "engine", "ui", "session", "waiting_room", "presentation", "setup", "scenario_editor", "scenario", "guide", "tick_controller", "hook", "validator", "endpoint", "settings"];
+export type ResourceType = (typeof RESOURCE_TYPES)[number];
+/**
+ * Where a resource's code sits inside its own directory, and what the
+ * entrypoint is called.
+ *
+ * The CLI fabricates this block: `new` writes it into the bundle and `update`
+ * leaves it alone, so an authored value was read by nothing. It is written down
+ * once here because the guard on authored input has to reject exactly what the
+ * templater is about to write, and a second copy could disagree with it (#473).
+ */
+export type ResourceLayout = {
+    logic: {
+        directory: string;
+        entrypoint: string;
+    };
+} | {
+    ui: {
+        entrypoint: string;
+    };
+};
+/**
+ * Where a resource lives in its package: a fixed slot for a type a game holds
+ * exactly one of, which is not named because the slot is the whole of its
+ * address, or a directory of named resources for every other type.
+ */
+export type ResourcePlacement = {
+    /** The fixed directory a singular resource lives in, e.g. `engine`. */
+    slot: ResourceType;
+    pluralDir?: undefined;
+} | {
+    slot?: undefined;
+    /** Directory holding all resources of this type, e.g. `hooks`. */
+    pluralDir: string;
+};
+export type PluralResourceMeta = Extract<ResourceMeta, {
+    pluralDir: string;
+}>;
+export type ResourceMeta = ResourcePlacement & {
+    type: ResourceType;
+    /**
+     * The code layout the templater writes into this type's bundle. Absent for
+     * the types that carry neither logic nor a UI.
+     */
+    layout?: ResourceLayout;
+    /** Bundle filename inside each resource directory, e.g. `engine.sdk.json`. */
+    bundleFile: string;
+    /** Key under which bundle paths are listed in seriousgaming.sdk.json. */
+    manifestKey: string;
+    kind: ResourceKind;
+    /** Human label used in reference output when this type is a referrer. */
+    label: string;
+    /** Merge the new definition onto the existing one (capability keeps `scope`). */
+    mergeDefinition: boolean;
+    /** Definition carries a `reads: string[]` of capability identifiers. */
+    hasReads: boolean;
+    /** Definition carries a `writes: string[]` of capability identifiers. */
+    hasWrites: boolean;
+    /** Definition carries a `crossTeamReads: string[]` of capability identifiers. */
+    hasCrossTeamReads: boolean;
+    /** Definition carries an `endpoints: string[]` of endpoint refs. */
+    declaresEndpoints: boolean;
+    /** Definition carries a `settings: string[]` of settings identifiers. */
+    readsSettings: boolean;
+    /** How other resources reference this one (target perspective). */
+    referenceSites: ReferenceSite[];
+};
+export declare const RESOURCE_METADATA: readonly ResourceMeta[];
+export declare const RESOURCE_METADATA_BY_MANIFEST_KEY: ReadonlyMap<string, ResourceMeta>;
+/** Metadata for a resource type, or undefined for a non-resource (`package`). */
+export declare function findResourceMeta(type: string): ResourceMeta | undefined;
+/**
+ * Nothing labels this resource, so it carries no `locales`.
+ *
+ * A game holds one of each interface, so no list ever names one and the name
+ * was never rendered (#448). The guide is the counter-example a hand-written
+ * list kept getting wrong: it fills a slot too, and it is genuinely titled. So
+ * is the presentation, the one interface a host lists outside a session, in a
+ * game's library, and so labels.
+ */
+export declare function isNamelessInterface(meta: ResourceMeta): boolean;
+export declare function getResourceMeta(type: ResourceType): ResourceMeta;
+/** Metadata for a type a package may hold several of, named by directory. */
+export declare function getPluralResourceMeta(type: ResourceType): PluralResourceMeta;