@wibly/internal-manifest 0.1.1

package/src/manifest.ts

@@ -0,0 +1,607 @@
+/**
+ * Top-level Experience-manifest Zod schema.
+ *
+ * Per Platform Spec §2.1 + §6.6.2, the manifest is the contract between
+ * the Studio (or a hand-authored Experience) and the Runtime. It captures
+ * every piece of Experience configuration the Runtime needs to drive a
+ * Session:
+ *
+ * - identity & ownership (`id`, `version`, `tenant`, `creator`),
+ * - safety / cost shape (`inferenceEnvelope`, `contentRating`,
+ *   `fallbackResponses`),
+ * - workflow (`workflow.phases`, `concurrentOpportunities`,
+ *   `lifecyclePolicies`),
+ * - state shape (`stateSchema`),
+ * - inference inputs (`promptSlots`, `personaBindings`),
+ * - rendering (`widgetDependencies`),
+ * - resolution (`scoring`).
+ *
+ * The schema is *strict on shape, permissive on content*. Strings have
+ * minimum lengths; numerics have positive / non-negative bounds; cross-
+ * field invariants live in `validate.ts`. The `stateSchema` slices and
+ * the `scoring` payload carry domain content the Runtime parses against
+ * its own per-Experience schemas — at the manifest layer we capture them
+ * as JSON-shaped values so a manifest can ship without round-tripping
+ * Zod-to-JSON-Schema (a Phase 2 concern; B4 + B7 own the producer side).
+ *
+ * Per chunk-A1 §4.1, every exported `Manifest*` type is `z.infer` of its
+ * schema's *output* — defaults and transforms produce concrete values
+ * downstream consumers can read without re-narrowing.
+ */
+
+import { z } from 'zod';
+
+import {
+  CallKindSchema,
+  CollectionRuleSchema,
+  InputSetSchema,
+  PhaseSchema,
+} from './phase.js';
+
+export { CallKindSchema };
+
+// -----------------------------------------------------------------------------
+// JSON value (used for state-schema slices and scoring payloads)
+// -----------------------------------------------------------------------------
+
+/**
+ * Recursive JSON-shaped value. Used wherever the manifest carries an
+ * opaque payload the Runtime parses against its own per-Experience Zod
+ * schema (state slices, scoring effect descriptors). The recursion is
+ * one-deep on `z.lazy` per Zod's idiom; the type is exported separately
+ * so consumers can annotate without re-deriving from the schema.
+ */
+export type JsonValue =
+  | string
+  | number
+  | boolean
+  | null
+  | readonly JsonValue[]
+  | { readonly [k: string]: JsonValue };
+
+const JsonValueSchema: z.ZodType<JsonValue> = z.lazy(() =>
+  z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.null(),
+    z.array(JsonValueSchema),
+    z.record(JsonValueSchema),
+  ]),
+);
+
+// -----------------------------------------------------------------------------
+// Identity / ownership
+// -----------------------------------------------------------------------------
+
+/**
+ * Experience id. Format is `exp_<nanoid>` per the prefixed-id convention
+ * from `@wibly/internal-shared/id` (matches the `experiences.id` PK shape from
+ * chunk A2). The manifest schema validates the prefix only; the full
+ * nanoid alphabet is enforced at the catalogue / publish boundary.
+ */
+export const ManifestIdSchema = z
+  .string()
+  .regex(/^exp_[A-Za-z0-9_-]+$/, 'must be an exp_ prefixed nanoid');
+
+/**
+ * Tenant id. Format is `tnt_<nanoid>`. Optional / nullable on the
+ * manifest because first-party Experiences (Hello World, Rashomon,
+ * Flatterer) ship without a tenant binding — they're owned by the
+ * platform rather than a corporate tenant.
+ */
+export const ManifestTenantIdSchema = z
+  .string()
+  .regex(/^tnt_[A-Za-z0-9_-]+$/, 'must be a tnt_ prefixed nanoid');
+
+/**
+ * Persona id. Format is `per_<nanoid>` per `pkId('per')` from chunk A2.
+ */
+export const PersonaIdSchema = z
+  .string()
+  .regex(/^per_[A-Za-z0-9_-]+$/, 'must be a per_ prefixed nanoid');
+
+// -----------------------------------------------------------------------------
+// Persona binding
+// -----------------------------------------------------------------------------
+
+/**
+ * One `(role, personaId)` pair. The Runtime resolves the active persona
+ * for a call by looking up the role tag (e.g. `'host'` / `'judge'`) in
+ * `personaBindings` and reading the bound persona id. Roles are
+ * manifest-local strings, not enum members, so a Creator can introduce
+ * new roles without a schema bump. Uniqueness on `role` is enforced by
+ * `validateManifest` (one role can't bind two personas).
+ */
+export const PersonaBindingSchema = z.object({
+  role: z.string().min(1),
+  personaId: PersonaIdSchema,
+});
+
+// -----------------------------------------------------------------------------
+// Inference envelope
+// -----------------------------------------------------------------------------
+
+/**
+ * The four quality tiers the Inference Gateway routes to (per chunk B2).
+ * `fast` and `standard` are the cheap-and-quick tiers; `premium` and
+ * `creative` route to higher-cost models. The manifest declares which
+ * tiers an Experience is allowed to request; the Gateway 402's anything
+ * outside the declared set.
+ */
+export const QualityTierSchema = z.enum([
+  'fast',
+  'standard',
+  'premium',
+  'creative',
+]);
+
+/**
+ * Per-Session inference budget, plus the set of quality tiers this
+ * Experience is allowed to request. The Runtime decrements against
+ * `maxLlmCallsPerSession` and `maxTtsSecondsPerSession` once per call;
+ * `maxTokensInPerCall` / `maxTokensOutPerCall` cap a single call.
+ *
+ * Per the spec's "the inference envelope is non-zero" structural check,
+ * every cap is `.positive()` (`maxTtsSecondsPerSession` is non-negative
+ * because a no-TTS Experience is a legitimate shape). `qualityTiers` is
+ * non-empty because an envelope with no allowed tiers makes the
+ * Experience unrunnable.
+ */
+export const InferenceEnvelopeSchema = z.object({
+  maxLlmCallsPerSession: z.number().int().positive(),
+  maxTokensInPerCall: z.number().int().positive(),
+  maxTokensOutPerCall: z.number().int().positive(),
+  maxTtsSecondsPerSession: z.number().int().nonnegative(),
+  qualityTiers: z.array(QualityTierSchema).min(1),
+});
+
+// -----------------------------------------------------------------------------
+// State schema (per-recipient slice descriptors)
+// -----------------------------------------------------------------------------
+
+/**
+ * Per Platform Spec §2.4.4 the Runtime maintains four state slices and
+ * projects per-recipient views onto them. The manifest declares the
+ * shape of each slice as a Zod-compatible JSON Schema. At the manifest
+ * layer the slice is `JsonValue` (opaque) — the per-Experience Zod
+ * schemas the Runtime consumes are produced at packaging time (B7) and
+ * shipped alongside the manifest blob, not parsed from it inline.
+ *
+ * `playerPublic` and `playerPrivate` form the per-player public/private
+ * split (visible to all players vs visible only to the player). `team`
+ * is optional because not every Experience uses team scope.
+ */
+export const StateSchemaSchema = z.object({
+  session: JsonValueSchema,
+  host: JsonValueSchema,
+  playerPublic: JsonValueSchema,
+  playerPrivate: JsonValueSchema,
+  team: JsonValueSchema,
+});
+
+// -----------------------------------------------------------------------------
+// Workflow
+// -----------------------------------------------------------------------------
+
+/**
+ * Workflow declaration: the initial phase the Runtime enters on session
+ * start, plus the full phase set. Per the chunk acceptance, the
+ * structural validator catches `initialPhase` not in `phases`,
+ * duplicate phase ids, transitions to non-existent phases, unreachable
+ * phases, and (via `PhaseSchema`) phases without an exit transition.
+ */
+export const WorkflowSchema = z.object({
+  initialPhase: z.string().min(1),
+  phases: z.array(PhaseSchema).min(1),
+});
+
+// -----------------------------------------------------------------------------
+// Concurrent opportunities
+// -----------------------------------------------------------------------------
+
+/**
+ * Concurrent opportunities (per Platform Spec §3.9.2 — the "Yellow"
+ * pattern). One opportunity attaches to one or more phases and runs as
+ * a parallel input collection alongside the phase's primary input set.
+ * `scoringEffect` is opaque at the manifest layer; the per-Experience
+ * scoring engine resolves it.
+ *
+ * `multiFire` (chunk B8c) opts the opportunity into repeat firing
+ * within a single phase entry. Default `false` preserves the chunk-
+ * B8b behaviour where each opportunity fires at most once per phase
+ * (avoiding loops on additional matching submissions). MVP fixtures
+ * stay on the single-fire path; Rashomon-style wagers that need
+ * repeat scoring set `multiFire: true` once the chunk-B8c scoring
+ * ledger is wired (the ledger row is idempotent on `messageId` via
+ * the submission's envelope id, which gives the dedup the multi-fire
+ * mode relies on).
+ */
+export const ConcurrentOpportunitySchema = z.object({
+  id: z.string().min(1),
+  attachedToPhases: z.array(z.string().min(1)).min(1),
+  inputSet: InputSetSchema,
+  collectionRule: CollectionRuleSchema,
+  scoringEffect: JsonValueSchema,
+  multiFire: z.boolean().optional(),
+});
+
+// -----------------------------------------------------------------------------
+// Scoring (per Platform Spec §8.2)
+// -----------------------------------------------------------------------------
+
+/**
+ * One scoring dimension (e.g. "funniness", "coherence", "speed"). The
+ * `weight` defaults to `1` and is used by aggregators to combine
+ * dimension scores into a final ranking. `scaleMin` / `scaleMax` lock
+ * the per-judgement range.
+ */
+export const ScoringDimensionSchema = z.object({
+  id: z.string().min(1),
+  label: z.string().min(1),
+  weight: z.number().nonnegative().default(1),
+  scaleMin: z.number(),
+  scaleMax: z.number(),
+});
+
+/**
+ * Discriminated aggregator descriptor. The Runtime applies the aggregator
+ * to the per-dimension scores in the scoring ledger to produce a single
+ * leaderboard value per actor. Add new variants in the chunk that needs
+ * them; the engine in B8c is the canonical consumer.
+ */
+export const ScoringAggregatorSchema = z.discriminatedUnion('kind', [
+  z.object({ kind: z.literal('sum') }),
+  z.object({ kind: z.literal('average') }),
+  z.object({ kind: z.literal('weighted_sum') }),
+  z.object({ kind: z.literal('max') }),
+  z.object({ kind: z.literal('min') }),
+]);
+
+/**
+ * One award (e.g. "Funniest", "Most Improved"). `dimensionId` references
+ * a `ScoringDimension.id`; cross-reference validation lives in
+ * `validateManifest`. `criterion.kind` discriminates the resolution
+ * rule — `top_n` picks the top N actors by the dimension's value;
+ * `threshold` picks every actor at or above a value.
+ */
+export const AwardCriterionSchema = z.discriminatedUnion('kind', [
+  z.object({
+    kind: z.literal('top_n'),
+    n: z.number().int().positive(),
+  }),
+  z.object({ kind: z.literal('threshold'), value: z.number() }),
+]);
+
+export const AwardDefinitionSchema = z.object({
+  id: z.string().min(1),
+  label: z.string().min(1),
+  dimensionId: z.string().min(1),
+  criterion: AwardCriterionSchema,
+});
+
+export const ScoringSchema = z.object({
+  dimensions: z.array(ScoringDimensionSchema),
+  aggregators: z.array(ScoringAggregatorSchema),
+  awards: z.array(AwardDefinitionSchema),
+});
+
+// -----------------------------------------------------------------------------
+// Lifecycle policies (per Platform Spec §3.8.2)
+// -----------------------------------------------------------------------------
+
+/**
+ * Lifecycle policy entries: declarative responses to Runtime situations
+ * a long-running Session can hit (player disconnect, host disconnect,
+ * inference outage, host reclaim, etc.). Each entry tags the
+ * `situation` and a discriminated `action`.
+ *
+ * The action set is intentionally narrow at MVP — `pause_session`,
+ * `continue_without_them`, `end_session`, `replace_actor` cover
+ * Hello World and the two first-party Experiences. Add new actions
+ * with the chunks that need them (B8a / B8b / B8c, B15).
+ *
+ * **Naming.** The literals match the verbs the chunk-B8c lifecycle
+ * policy engine reads from the manifest (per Development Spec
+ * §6.10c "policy.ts applies the manifest's declarative response").
+ * Earlier drafts of this schema used the shorter `pause` /
+ * `continue` literals; B8c's plan settled the names as
+ * `pause_session` / `continue_without_them` because `continue`
+ * (without its object) is ambiguous with the JS keyword and
+ * `pause` reads as ambiguous between "pause this phase" and "pause
+ * the entire session" once concurrent opportunities (P10) land.
+ */
+export const LifecycleSituationSchema = z.enum([
+  'player_disconnect',
+  'host_disconnect',
+  'host_reclaim',
+  'inference_outage',
+  'safety_block',
+]);
+
+export const LifecycleActionSchema = z.discriminatedUnion('kind', [
+  z.object({
+    kind: z.literal('pause_session'),
+    /** Wall-clock ms to pause before falling back to `fallback`. */
+    timeoutMs: z.number().int().positive(),
+    fallback: z.enum(['continue_without_them', 'end_session']),
+  }),
+  z.object({ kind: z.literal('continue_without_them') }),
+  z.object({ kind: z.literal('end_session') }),
+  z.object({
+    kind: z.literal('replace_actor'),
+    /** Persona role to bind in place of the disconnected actor. */
+    withRole: z.string().min(1),
+  }),
+]);
+
+export const LifecyclePolicySchema = z.object({
+  situation: LifecycleSituationSchema,
+  action: LifecycleActionSchema,
+});
+
+// -----------------------------------------------------------------------------
+// Prompt slots (per docs/conventions/prompt-composition.md)
+// -----------------------------------------------------------------------------
+
+/**
+ * Per the prompt-composition doc, every slot value is either a literal
+ * string or a template with named vars interpolated from session state.
+ * Templates use `{varName}` placeholders; the composer (chunk B4)
+ * resolves them. `vars` is non-empty when supplied — a template with no
+ * vars is just a literal and should be authored as one.
+ */
+export const PromptSlotValueSchema = z.union([
+  z.string(),
+  z.object({
+    template: z.string().min(1),
+    vars: z.array(z.string().min(1)).min(1).optional(),
+  }),
+]);
+
+/**
+ * The known set of `callKind`s the prompt composer (chunk B4) maps to
+ * the eight-layer prompt. Listed in
+ * `docs/conventions/prompt-composition.md`. Every callKind that appears
+ * here MUST appear in that document; new callKinds land in the chunk
+ * that introduces them with the doc updated in the same commit.
+ *
+ * Defined in `phase.ts` (re-exported above) so the chunk-B8c
+ * `WorkflowSideEffect.inference.callKind` schema can reference it
+ * without a circular import.
+ */
+
+/**
+ * Manifest-supplied prompt content. `experienceSystem` is the layer-3
+ * Experience system message; `callTypes` keys per `callKind` populate
+ * layer 4; `outputSchemas` populates layer 7 with a JSON-shaped schema
+ * the Gateway renders. Per the prompt-composition doc, the platform
+ * supplies the structural layers (1, 4-structural, 5, 6, 8) and the
+ * Persona Service supplies layer 2; everything below is the manifest's
+ * contribution.
+ */
+export const PromptSlotsSchema = z.object({
+  experienceSystem: PromptSlotValueSchema,
+  callTypes: z.record(CallKindSchema, PromptSlotValueSchema),
+  outputSchemas: z.record(CallKindSchema, JsonValueSchema).optional(),
+});
+
+// -----------------------------------------------------------------------------
+// Fallback responses
+// -----------------------------------------------------------------------------
+
+/**
+ * Pre-written copy the Runtime emits when an inference call fails or
+ * the safety pipeline blocks the model output. Keyed per `callKind` so
+ * a host_judge fallback is distinct from a host_recap fallback.
+ */
+export const FallbackResponsesSchema = z.record(CallKindSchema, z.string().min(1));
+
+// -----------------------------------------------------------------------------
+// Content rating
+// -----------------------------------------------------------------------------
+
+/**
+ * Safety-pipeline floor values. Derived from
+ * {@link ExperienceContentRatingTierSchema} via
+ * `safetyFloorFromContentRatingTier` — do not set independently on
+ * the manifest.
+ */
+export const ContentRatingFloorSchema = z.enum(['general', 'pg13', 'mature']);
+
+export const ContentRatingAudienceSchema = z.enum([
+  'consumer',
+  'corporate',
+  'private',
+]);
+
+/**
+ * Unified Experience content-rating tier. Drives Safety posture,
+ * Portal badge copy, and smut-tier UI eligibility.
+ */
+export const ExperienceContentRatingTierSchema = z.enum([
+  'none',
+  'pg13',
+  'mature',
+  'extra_smut',
+]);
+
+/**
+ * `tier` is the single content-rating selector for an Experience.
+ * `audiences` lists the audience tags an Experience advertises against
+ * (e.g. `consumer`, `corporate`) — edited on the Studio Audience tab.
+ */
+export const ContentRatingSchema = z.object({
+  tier: ExperienceContentRatingTierSchema,
+  audiences: z.array(ContentRatingAudienceSchema).min(1),
+});
+
+// -----------------------------------------------------------------------------
+// Portal metadata (per Surfaces & Identity Addendum §4.3, chunk B11)
+// -----------------------------------------------------------------------------
+
+/**
+ * Occasions the User Portal's catalogue page uses to group titles for
+ * browsing. The internal Catalogue document still groups by mechanic
+ * (Improv / Argumentative / Deduction etc.); this enum is purely the
+ * Portal-display axis. Adding a value here lands in the chunk that
+ * needs it; do not weaken the enum to `z.string()` ("the Portal can
+ * filter on anything") — the Portal's filter UI is a hard-coded set.
+ */
+export const OccasionTagSchema = z.enum([
+  'party',
+  'date_night',
+  'family',
+  'quick_game',
+  'team_building',
+]);
+
+export const GameplayImageSchema = z.object({
+  title: z.string().min(1),
+  imageUrl: z.string().url(),
+});
+
+export const GameplayVideoSchema = z.object({
+  title: z.string().min(1),
+  videoUrl: z.string().url(),
+});
+
+/**
+ * Per-Experience portal-page metadata. Renders the User Portal's
+ * `/experience/:id` page (per Surfaces & Identity Addendum §4.3).
+ * Every published Experience must ship this block; the chunk-B11
+ * build pipeline rejects manifests that omit it.
+ *
+ * URL fields are validated as URLs at the schema level; assets are
+ * R2-hosted in production. Content-rating badge and smut-tier UI are
+ * derived from the manifest-level `contentRating.tier`, not stored
+ * here.
+ *
+ * @deferred chunk-E1 — Rashomon (separate Lovable repo) ships a
+ * minimal `portalMetadata` block when that Experience lands in-tree.
+ * @deferred chunk-E2 — Flatterer (separate Lovable repo) ships a
+ * minimal `portalMetadata` block when that Experience lands in-tree.
+ */
+export const PortalMetadataSchema = z
+  .object({
+    heroImageUrl: z.string().url(),
+    gameplayImages: z.array(GameplayImageSchema).default([]),
+    gameplayVideo: GameplayVideoSchema.optional(),
+    personaPreviewAudioUrl: z.string().url().optional(),
+    sampleRoundDescription: z.string().min(1),
+    occasionTags: z.array(OccasionTagSchema).min(1),
+    minPlayers: z.number().int().min(1).default(3),
+    maxPlayers: z.number().int().min(1).default(8),
+    estimatedDurationMinutes: z.number().int().min(1).default(30),
+  })
+  .superRefine((value, ctx) => {
+    if (value.maxPlayers < value.minPlayers) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: 'maxPlayers must be greater than or equal to minPlayers',
+        path: ['maxPlayers'],
+      });
+    }
+  });
+
+// -----------------------------------------------------------------------------
+// Bundle reservations (Phase 2 — inert in MVP)
+// -----------------------------------------------------------------------------
+
+/**
+ * Phase-2 Bundle manifest mirrors (Chunk B18 reservation).
+ * Reserved for Phase 2; current Runtime ignores these. The validator
+ * accepts them but does not enforce structural cross-checks — P-bundles
+ * owns that logic.
+ *
+ * @deferred Phase 2 — P-bundles
+ */
+export const BundleContextSlotsSchema = z.record(JsonValueSchema);
+
+// -----------------------------------------------------------------------------
+// Manifest top-level
+// -----------------------------------------------------------------------------
+
+/**
+ * The root Experience manifest. Every field is a stable contract: a
+ * future chunk that needs to add a top-level field bumps a manifest
+ * compatibility version (Phase 2) rather than ad-hoc widening this
+ * schema.
+ *
+ * `tenant` is `null` for first-party Experiences (Hello World, the
+ * MVP fixtures) and a `tnt_…` id otherwise. The Runtime trusts the
+ * tenant binding here only as a hint — authoritative tenant scoping
+ * lives on `experiences.tenant_id` in the catalogue (chunk A2).
+ *
+ * `createdAt` is an ISO-8601 timestamp string. The DB-side timestamp
+ * lives on `experience_versions.created_at`; this field captures the
+ * value the Studio pinned at manifest authoring time so the manifest
+ * blob is self-describing.
+ */
+export const ManifestSchema = z.object({
+  id: ManifestIdSchema,
+  version: z.string().min(1),
+  name: z.string().min(1),
+  description: z.string().min(1),
+  tenant: ManifestTenantIdSchema.nullable().optional(),
+  creator: z.string().min(1),
+  createdAt: z.string().datetime({ offset: true }),
+  personaBindings: z.array(PersonaBindingSchema),
+  inferenceEnvelope: InferenceEnvelopeSchema,
+  stateSchema: StateSchemaSchema,
+  workflow: WorkflowSchema,
+  concurrentOpportunities: z.array(ConcurrentOpportunitySchema),
+  scoring: ScoringSchema,
+  lifecyclePolicies: z.array(LifecyclePolicySchema),
+  promptSlots: PromptSlotsSchema,
+  fallbackResponses: FallbackResponsesSchema,
+  widgetDependencies: z.array(z.string().min(1)),
+  contentRating: ContentRatingSchema,
+  portalMetadata: PortalMetadataSchema,
+  /** Reserved for Phase 2; current Runtime ignores these. */
+  bundleCompatible: z.boolean().default(false).optional(),
+  /** Reserved for Phase 2; current Runtime ignores these. */
+  bundleScopedDimensions: z.array(z.string().min(1)).default([]).optional(),
+  /** Reserved for Phase 2; current Runtime ignores these. */
+  bundleWriteDimensions: z.array(z.string().min(1)).default([]).optional(),
+  /** Reserved for Phase 2; current Runtime ignores these. */
+  bundleContextSlots: BundleContextSlotsSchema.default({}).optional(),
+});
+
+// -----------------------------------------------------------------------------
+// Inferred types
+// -----------------------------------------------------------------------------
+
+export type ManifestId = z.infer<typeof ManifestIdSchema>;
+export type ManifestTenantId = z.infer<typeof ManifestTenantIdSchema>;
+export type PersonaId = z.infer<typeof PersonaIdSchema>;
+export type PersonaBinding = z.infer<typeof PersonaBindingSchema>;
+export type QualityTier = z.infer<typeof QualityTierSchema>;
+export type InferenceEnvelope = z.infer<typeof InferenceEnvelopeSchema>;
+export type StateSchema = z.infer<typeof StateSchemaSchema>;
+export type Workflow = z.infer<typeof WorkflowSchema>;
+export type ConcurrentOpportunity = z.infer<typeof ConcurrentOpportunitySchema>;
+export type ScoringDimension = z.infer<typeof ScoringDimensionSchema>;
+export type ScoringAggregator = z.infer<typeof ScoringAggregatorSchema>;
+export type AwardCriterion = z.infer<typeof AwardCriterionSchema>;
+export type AwardDefinition = z.infer<typeof AwardDefinitionSchema>;
+export type Scoring = z.infer<typeof ScoringSchema>;
+export type LifecycleSituation = z.infer<typeof LifecycleSituationSchema>;
+export type LifecycleAction = z.infer<typeof LifecycleActionSchema>;
+export type LifecyclePolicy = z.infer<typeof LifecyclePolicySchema>;
+export type PromptSlotValue = z.infer<typeof PromptSlotValueSchema>;
+export type CallKind = z.infer<typeof CallKindSchema>;
+export type PromptSlots = z.infer<typeof PromptSlotsSchema>;
+export type FallbackResponses = z.infer<typeof FallbackResponsesSchema>;
+export type ContentRatingFloor = z.infer<typeof ContentRatingFloorSchema>;
+export type ContentRatingAudience = z.infer<typeof ContentRatingAudienceSchema>;
+export type ExperienceContentRatingTier = z.infer<
+  typeof ExperienceContentRatingTierSchema
+>;
+export type ContentRating = z.infer<typeof ContentRatingSchema>;
+export type OccasionTag = z.infer<typeof OccasionTagSchema>;
+export type GameplayImage = z.infer<typeof GameplayImageSchema>;
+export type GameplayVideo = z.infer<typeof GameplayVideoSchema>;
+export type PortalMetadata = z.infer<typeof PortalMetadataSchema>;
+export type BundleContextSlots = z.infer<typeof BundleContextSlotsSchema>;
+export type Manifest = z.infer<typeof ManifestSchema>;