@idle-screens/schema 3.15.0 → 3.16.1

package/dist/index.d.ts

@@ -150,8 +150,8 @@ interface BackgroundDrift {
 /**
  * A paint-level transform applied to a whole layer at draw time, about the
  * viewport centre: translate by (`x`, `y`) in `min(w, h)` units, rotate by
- * `rotate` degrees, scale by `scale` (× `scaleX` horizontally — `scaleX`
- * toward 0 reads as a turn about the vertical axis). Kept out of the
+ * `rotate` degrees, scale by `scale` (× `scaleX` horizontally, × `scaleY`
+ * vertically — `scaleX` toward 0 reads as a turn about the vertical axis). Kept out of the
  * structural signature, so it glides under steering, a `timeline` key or a
  * `morph` — a camera for timed pieces, a slow drift for ambient ones. Every
  * field optional; an empty transform is the identity. **Native:** ignored ⇒
@@ -162,9 +162,15 @@ interface LayerTransform {
     y?: number;
     scale?: number;
     scaleX?: number;
+    /**
+     * Extra vertical scale, × `scale` (default 1; ±8, negative flips upside
+     * down). With `scaleX` it squashes and stretches: wide-and-short on a
+     * landing, narrow-and-tall on take-off.
+     */
+    scaleY?: number;
     rotate?: number;
     /**
-     * What `scale` / `scaleX` / `rotate` turn about. `'viewport'` (default) is
+     * What `scale` / `scaleX` / `scaleY` / `rotate` turn about. `'viewport'` (default) is
      * the viewport centre — a camera move. `'anchor'` is the layer's own
      * `position` point (with `dx`/`dy`; for a `list`/`table` layout, the block's
      * anchor; without `position`, the centre of its `region`) — a slam word
@@ -252,7 +258,7 @@ interface LayerSpec {
         y?: [number, number];
     };
     /**
-     * Sinusoidal opacity breathing. SAFETY: amp is capped (LIMITS.maxPulseAmp),
+     * Sinusoidal opacity breathing (`amp: 0` is none). SAFETY: amp is capped (LIMITS.maxPulseAmp),
      * period has a floor (LIMITS.minPulsePeriod — max 2 Hz), and every entity gets
      * its own seeded phase, so a layer can never strobe in unison. Effective alpha
      * is clamped to 0..1.
@@ -578,7 +584,9 @@ type SpriteSpec = {
  * n-gon of the seeded `radius` (circumradius), point up; `points` (3..24
  * unit coordinates in −1..1, scaled by the radius) draws any facet — a
  * Picasso shard, a Kandinsky triangle, a Mondrian plane. `soft` feathers
- * the fill from the centre like a soft circle. Rotates with `spin`.
+ * the fill from the centre like a soft circle. Rotates with `spin`. A
+ * `points` polygon with `stroke`, `fill: false` or `gradient` draws as the
+ * closed path through its points (X711) — keyed points become line art.
  */
  | {
     kind: 'polygon';
@@ -684,6 +692,14 @@ interface TextNumber {
     prefix?: string;
     suffix?: string;
     grouping?: boolean;
+    /**
+     * Zero-pad the integer part to at least this many digits (1..12, default
+     * 1): `minDigits: 4` paints 42 as `0042` — a fixed-width frame counter.
+     * Padding happens before grouping, as `Intl`'s `minimumIntegerDigits`
+     * does, so pair it with `grouping: false` unless you want `0,042`. The
+     * sign stays outside the padding (`-0042`). Paint, like the rest.
+     */
+    minDigits?: number;
 }
 /**
  * What a text layer is *for* — a declaration, not a pixel. `read` says the
@@ -958,6 +974,7 @@ declare const LIMITS: {
     readonly maxPolygonSides: 12;
     readonly maxShapePoints: 24;
     readonly maxTextNumberDecimals: 6;
+    readonly maxTextNumberMinDigits: 12;
     readonly maxTextAffix: 64;
     readonly maxRevealRise: 1;
     readonly maxRockAmp: 45;
@@ -1104,7 +1121,8 @@ interface PathGradientStop {
  * An outline drawn along every subpath of a path polygon (open ones too).
  * `width` is in unit-box units. `draw` paints only a stretch of it — see
  * `StrokeDraw`: every subpath of the part counts as one pen line, in the
- * order the path draws them.
+ * order the path draws them (or, with `draw.mode: 'each'`, each subpath
+ * draws over the whole span at once).
  */
 interface PathStroke {
     color: string;
@@ -1125,6 +1143,15 @@ interface PathStroke {
 interface StrokeDraw {
     start?: number;
     end?: number;
+    /**
+     * How a path stroke's subpaths share the span. `'run'` (default): one pen
+     * run through every subpath in draw order — a signature, a contour.
+     * `'each'`: every subpath is cut to the same `start`..`end` of its **own**
+     * length, so they all draw at once — a burst, a tick dial, hatching. An
+     * enum: a steer or key on it steps. No effect on a `stroke` sprite (one
+     * line either way).
+     */
+    mode?: 'run' | 'each';
 }
 /**
  * One piece of a multi-colour path drawing (`polygon.parts`), drawn back to
@@ -1329,9 +1356,9 @@ declare function spriteVariants(sprite: SpriteSpec): number;
 declare function buildEntities(layer: LayerSpec, rng: Rng, w: number, h: number, scale?: number, countScale?: number): Entity[];
 /**
  * The string a `textBlock` paints: its `text`, or with `number` the
- * counter's `prefix + value + suffix` — rounded to `decimals`, thousands
- * grouped with commas unless `grouping: false`. Locale-free, so every
- * device draws the same digits.
+ * counter's `prefix + value + suffix` — rounded to `decimals`, the integer
+ * part zero-padded to `minDigits`, thousands grouped with commas unless
+ * `grouping: false`. Locale-free, so every device draws the same digits.
  */
 declare function textBlockText(s: {
     text: string;
@@ -1897,6 +1924,32 @@ declare function describeScene(spec: SaverSpec, options?: {
     times?: number[];
 }): SceneDescription;
 
+/**
+ * Analytic models of the paint-level layer fields — `transform` (with its
+ * `origin`), `opacity`, and the `groups` a layer paints through — shared by
+ * the renderer's maths, perception and the advisories. Internal, not
+ * exported from the package. They mirror SpecInstance's draw-time canvas
+ * transform: a member of a group is drawn through G·L, where L is the layer's
+ * own transform (about its origin) and G the group's (about the viewport
+ * centre), so a point p lands at G(L(p)).
+ */
+
+/** The numeric fields of a `LayerTransform`, at their identity values. */
+declare const TRANSFORM_FIELDS: {
+    readonly x: 0;
+    readonly y: 0;
+    readonly scale: 1;
+    readonly scaleX: 1;
+    readonly scaleY: 1;
+    readonly rotate: 0;
+};
+type TransformField = keyof typeof TRANSFORM_FIELDS;
+/**
+ * Every value each numeric transform field takes over some stretch of time,
+ * as `[min, max]` — what a timeline that glides a transform sweeps through.
+ */
+type TransformRange = Record<TransformField, [number, number]>;
+
 interface PerceiveOptions {
     viewport?: {
         width: number;
@@ -1957,8 +2010,16 @@ declare function luminanceGrid(spec: SaverSpec, opts?: LuminanceGridOptions): Lu
  * fixed — it moves, emits, links, trails, orbits or cycles its text — and so may reach
  * any cell. Each entity is a disc about its position that holds its whole
  * outline at its largest size under any rotation: generous, never short.
+ *
+ * `sweep` (by layer index) widens a layer to everywhere its own and its
+ * group's transforms can carry it while they range over the given values —
+ * a timeline that glides them (X681). Either side missing is held at the
+ * spec's own transform.
  */
-declare function layerCellFootprints(spec: SaverSpec, opts?: LuminanceGridOptions): Array<number[] | null>;
+declare function layerCellFootprints(spec: SaverSpec, opts?: LuminanceGridOptions, sweep?: ReadonlyMap<number, {
+    layer?: TransformRange;
+    group?: TransformRange;
+}>): Array<number[] | null>;
 /**
  * Encode a luminance grid as a braille "image": each output character is a 2×4
  * pixel cell, ordered-dithered so mid-tones render as dot density. A grid of
@@ -2284,6 +2345,41 @@ interface TimelineFlashReport {
     boundariesPerSecond?: number;
 }
 declare function timelineFlashReport(spec: SaverSpec): TimelineFlashReport;
+interface FlashSamplingForecast {
+    /**
+     * The check would run out of frames to resolve. {@link timelineFlashReport}
+     * is then certain to fail: with `incomplete` at this `at` and
+     * `boundariesPerSecond`, unless it finds a flash in the frames it does
+     * resolve first. False means it is never `incomplete`, and its verdict
+     * turns on the pixels.
+     */
+    exhausted: boolean;
+    /** With `exhausted`: start (scene ms, within the lap) of the window the budget runs out in; otherwise null. */
+    at: number | null;
+    /** With `exhausted`: paint-key changes in that window's busiest second. */
+    boundariesPerSecond?: number;
+    /** Frames the check resolves if it finds no flash: at most `budget`. */
+    samples: number;
+    /** Frames the whole walk would take with no budget (more than `budget` exactly when `exhausted`). */
+    needed: number;
+    /** The check's frame budget ({@link MAX_TOTAL_SAMPLES}). */
+    budget: number;
+    /**
+     * The report {@link timelineFlashReport} returns if it finds no flash: the
+     * pass, or the fail-closed `incomplete` one (its `flashesPerSecond` and
+     * `flashingArea` are 0 here; the real report carries whatever it checked).
+     */
+    report: TimelineFlashReport;
+}
+/**
+ * {@link timelineFlashReport}'s sampling plan, with no frame resolved: the
+ * same dense windows, per-cell pre-check and budgeted walk, so whether the
+ * check will run out of budget is known for the cost of the arithmetic. A
+ * caller that cannot afford the full check (it resolves up to
+ * {@link MAX_TOTAL_SAMPLES} luminance grids) can refuse `exhausted` scenes
+ * outright: publishing refuses them too.
+ */
+declare function flashSamplingForecast(spec: SaverSpec): FlashSamplingForecast;
 
 /**
  * The `field` background sampler — seeded, dependency-free value noise that
@@ -2661,17 +2757,48 @@ interface ScenePeriod {
     period: number | null;
     /** One line per part that sets or breaks the period, e.g. `layers[2] pulse: 4000 ms`. */
     parts: string[];
+    /** What drives each of `parts`, index for index: `pulse`, `grow`, `rock`, `spin`, `path`, `orbit`, `emit`, `cycle`, `caret`, `background`, `timeline`. */
+    kinds: PeriodKind[];
     /** Why it is null (empty otherwise). */
     reasons: string[];
 }
-/** The repeat period of `spec` — see the module comment. */
-declare function scenePeriod(spec: SaverSpec): ScenePeriod;
+type PeriodKind = 'timeline' | 'background' | 'pulse' | 'grow' | 'rock' | 'emit' | 'spin' | 'cycle' | 'caret' | 'path' | 'orbit';
+/**
+ * Periodic parts that run on scene time and change smoothly, so a looping
+ * timeline's wrap never makes them jump: they carry on through it. A lap
+ * that does not divide their period still loops seamlessly on screen — only
+ * an exact export of one lap would differ (F145, X725, X823).
+ */
+declare const SEAMLESS_PERIOD_KINDS: ReadonlySet<PeriodKind>;
+/**
+ * The repeat period of `spec` — see the module comment. `skip` leaves out the
+ * periodic parts of those kinds, as if they were static (the loop-seam
+ * advisory passes `SEAMLESS_PERIOD_KINDS`).
+ */
+declare function scenePeriod(spec: SaverSpec, skip?: ReadonlySet<PeriodKind>): ScenePeriod;
 /**
  * The period of everything in the scene except its timeline — what a
  * looping timeline's lap has to be a multiple of for one lap to loop
  * seamlessly.
  */
-declare function periodWithoutTimeline(spec: SaverSpec): ScenePeriod;
+declare function periodWithoutTimeline(spec: SaverSpec, skip?: ReadonlySet<PeriodKind>): ScenePeriod;
+/**
+ * How many-fold rotationally symmetric a sprite's drawing is about the point
+ * `spin` turns it on: a spinning layer looks the same again after 360°/n,
+ * so its spin repeats n times a lap (X709). `Infinity` for a circle or ring
+ * (spin never shows); 1 when no symmetry is found, or the drawing has
+ * something the check does not model (a gradient, a part-drawn stroke, a
+ * stretched `span`, a soft fill off its pivot) — 1 is the old behaviour, a
+ * period that is never too short.
+ *
+ * Regular `sides` n-gons are n-fold. For `points` and path drawings, each
+ * paint (fill colour and rule, stroke colour and width, opacity) is checked
+ * on its own: every vertex and segment midpoint of its outline, turned by
+ * ±360°/n, must lie on that same paint's outline, to within 0.2 % of the
+ * drawing's radius — sub-pixel, past the path flattener's own error. Draw
+ * order between overlapping parts is not modelled.
+ */
+declare function spinSymmetry(sp: SpriteSpec): number;
 
 /**
  * Reproduces the hand-coded Fish Aquarium saver as pure DATA — the discriminating test
@@ -3088,13 +3215,15 @@ declare function trimPolyline(pts: Array<{
 /**
  * A part's subpaths cut to a `draw` span: the lines are one pen run in draw
  * order (a closed ring counts its closing edge), so `end` sweeps through the
- * first subpath, then the next. A trimmed ring comes back open; untouched
- * lines are returned as they were. Memoised per (lines, span).
+ * first subpath, then the next. With `mode: 'each'` every line is cut to the
+ * same fractions of its own length instead, so all of them draw at once. A
+ * trimmed ring comes back open; untouched lines are returned as they were.
+ * Memoised per (lines, span, mode).
  */
 declare function trimLines(lines: Array<{
     points: Array<[number, number]>;
     closed: boolean;
-}>, a: number, b: number): Array<{
+}>, a: number, b: number, mode?: StrokeDraw['mode']): Array<{
     points: Array<[number, number]>;
     closed: boolean;
 }>;
@@ -3134,7 +3263,11 @@ interface FlattenedPath {
  */
 type PathFillRule = 'auto' | 'nonzero' | 'evenodd';
 declare function flattenPath(d: string, rule?: PathFillRule): FlattenedPath;
-/** A polygon drawn from SVG paths: one `path`, or a multi-colour drawing of `parts`. */
+/**
+ * A polygon drawn from SVG paths: one `path`, a multi-colour drawing of
+ * `parts`, or a `points` polygon that carries path paint (see
+ * `isPointsPath`).
+ */
 declare function isPathPolygon(s: SpriteSpec): boolean;
 /** One drawable piece of a path polygon, resolved: its outline, paint and part-space box. */
 interface ResolvedPart {
@@ -3181,5 +3314,5 @@ declare function pathFrame(s: PolygonSprite, r: number, w: number, h: number): {
     uniform: boolean;
 };
 
-export { AQUARIUM_SPEC, AURORA_SPEC, COHESION_T, COMETS_SPEC, CONSTELLATION_SPEC, DASHBOARD_SPEC, DEFAULT_KEY_DUR, DITHER_ALPHA, DITHER_TILE, EXAMPLE_BY_ID, EXAMPLE_SEQUENCES, EXAMPLE_SPECS, FACETS_SPEC, FIELD_BUCKET_MS, FIELD_DRIFT_DEFAULT_AMOUNT, FIELD_RASTER_SHORT_SIDE, FIELD_RASTER_SHORT_SIDE_LOW, FINISH_ANIMATE_HZ, GRAIN_ALPHA, GRAIN_TILE, HAIKU_SPEC, LANTERNS_SPEC, LIMITS, LOBBY_TALK_SPEC, MATRIX_RAIN_SPEC, MAX_PATH_POINTS, MAX_SCENE_PERIOD, MOTION_FIELDS, MURMUR_SPEC, NOSTALGHIA_CANDLE_SPEC, ORRERY_SPEC, PHASE_DUET_SPEC, PINGS_SPEC, POLYGONS_SPEC, PROCESSION_SPEC, RAIN_SPEC, RELAY_BOARD_SPEC, SAKURA_SPEC, SCHEMA_EXAMPLES, SCHEMA_VERSION, SHARD_FALL_SPEC, SIGNAL_BOARD_SPEC, SNOWFALL_SPEC, SPARSE_NIGHT_SPEC, STEER_EASES, THERMAL_FIELD_SPEC, THREE_MOVEMENTS_SEQUENCE, TYPED_CUE_SPEC, WARP_MAX_SCALE, WARP_NEAR, WARP_TUNNEL_SPEC, WEB_WORK_SPEC, adviseSequence, adviseSpec, alphaAt, applyDeltasShared, applyDeltasToSpec, assertValidSequence, assertValidSpec, bayerMatrix, bayerTilePixels, bedRenderSeed, breakTextBlock, buildEntities, buriedAreaOf, canMorph, canWrapMorph, canonicalSpecPath, cohesionOf, compileSaver, compileSequence, createFinishPass, createSceneCanvas, describeScene, diffScenes, dominanceRanking, drawSpan, easeGlide, easeSmooth, emitEnvelope, emitWindow, entityScales, fieldAt, fieldOctaves, fieldRgb, fieldRgbAt, fieldSampleTime, finishStrength, flattenPath, grainOffset, grainTilePixels, graphemeClusters, hasHotSwapSequence, headingAt, hexToRgb255, ignoredPropertyPaths, isCombiningKana, isFullWidth, isPathPolygon, latticeHash, layerCellFootprints, layerCohesion, lerpPathD, lerpSpec, lerpValue, lifeAlphaAt, lifeStaggerAt, linkEdges, linkMaxDistPx, linkPairs, luminanceGrid, manifestFor, morphChainRoot, morphNothingMorphable, motionStats, nextKeyAfter, normalizeSeed, pathFrame, pathParts, perceiveScene, perceiveSequenceFrame, periodWithoutTimeline, pickScreenOp, positionAt, presentWithFinish, readSpecPath, renderBrailleMap, renderDensityMap, resolveSegment, resolveSpecPath, resolveTimelineAt, revealState, rgb255Luma, rotationAt, sceneColour, scenePeriod, seamCauseOf, seamsWorthWarning, segmentRenderSeed, segmentStart, sequenceSteerablePaths, sequenceSwapCompatible, sequenceWantsFinish, sizeAt, spriteIndexAt, spriteVariants, steerablePaths, strokeDrawnSamples, strokeLines, structuralSignature, textBlockAnchorOffset, textBlockText, textMetricsClassFor, textSprites, textStringsDiffer, textStringsOf, textWidthEm, timelineFlashReport, timelineLocalTime, timelineSampleTimes, timelineSampleTimesAfter, timelineTracks, trimLines, trimPolyline, validateSequence, validateSpec, validateSpecPaths, wipeMask, withoutTimeline };
-export type { BackgroundDrift, BackgroundSpec, BandSpec, CapabilityTier, CohesionRead, CycleSpec, DominanceEntry, Entity, FieldBackground, FieldDrift, FinishPass, FinishSpec, FlattenedPath, GlideEase, GradientStop, IdleSequence, LayerCohesion, LayerGroup, LayerMotionStats, LayerSnapshot, LayerSpec, LayerTransform, LinkEdge, LuminanceGrid, LuminanceGridOptions, MotionEase, MotionSpec, PathGradient, PathGradientStop, PathPart, PathStroke, PerceiveOptions, PerceiveSequenceOptions, Placed, ResolveOptions, ResolvedPart, ResolvedSegment, RevealState, SaverSpec, SceneColour, SceneDescription, SceneDiff, ScenePerception, ScenePeriod, SceneSnapshot, SchemaExample, ScreenOp, SequenceExample, SequenceFramePerception, SequenceMountContext, SequenceSaverInstance, SequenceSaverPlugin, SequenceSegment, SequenceTransition, SpecError, SpecMountContext, SpecWarning, SpriteSpec, SteerDelta, StrokeDraw, TextBlockAnchor, TextBlockLine, TextMetricsClass, TextNumber, TextRevealInput, TextRevealSpec, TextRole, TextSpriteInfo, Timeline, TimelineFlashReport, TimelineKey, ValidationResult, WanderOsc, WarningBox, WipeTransition };
+export { AQUARIUM_SPEC, AURORA_SPEC, COHESION_T, COMETS_SPEC, CONSTELLATION_SPEC, DASHBOARD_SPEC, DEFAULT_KEY_DUR, DITHER_ALPHA, DITHER_TILE, EXAMPLE_BY_ID, EXAMPLE_SEQUENCES, EXAMPLE_SPECS, FACETS_SPEC, FIELD_BUCKET_MS, FIELD_DRIFT_DEFAULT_AMOUNT, FIELD_RASTER_SHORT_SIDE, FIELD_RASTER_SHORT_SIDE_LOW, FINISH_ANIMATE_HZ, GRAIN_ALPHA, GRAIN_TILE, HAIKU_SPEC, LANTERNS_SPEC, LIMITS, LOBBY_TALK_SPEC, MATRIX_RAIN_SPEC, MAX_PATH_POINTS, MAX_SCENE_PERIOD, MOTION_FIELDS, MURMUR_SPEC, NOSTALGHIA_CANDLE_SPEC, ORRERY_SPEC, PHASE_DUET_SPEC, PINGS_SPEC, POLYGONS_SPEC, PROCESSION_SPEC, RAIN_SPEC, RELAY_BOARD_SPEC, SAKURA_SPEC, SCHEMA_EXAMPLES, SCHEMA_VERSION, SEAMLESS_PERIOD_KINDS, SHARD_FALL_SPEC, SIGNAL_BOARD_SPEC, SNOWFALL_SPEC, SPARSE_NIGHT_SPEC, STEER_EASES, THERMAL_FIELD_SPEC, THREE_MOVEMENTS_SEQUENCE, TYPED_CUE_SPEC, WARP_MAX_SCALE, WARP_NEAR, WARP_TUNNEL_SPEC, WEB_WORK_SPEC, adviseSequence, adviseSpec, alphaAt, applyDeltasShared, applyDeltasToSpec, assertValidSequence, assertValidSpec, bayerMatrix, bayerTilePixels, bedRenderSeed, breakTextBlock, buildEntities, buriedAreaOf, canMorph, canWrapMorph, canonicalSpecPath, cohesionOf, compileSaver, compileSequence, createFinishPass, createSceneCanvas, describeScene, diffScenes, dominanceRanking, drawSpan, easeGlide, easeSmooth, emitEnvelope, emitWindow, entityScales, fieldAt, fieldOctaves, fieldRgb, fieldRgbAt, fieldSampleTime, finishStrength, flashSamplingForecast, flattenPath, grainOffset, grainTilePixels, graphemeClusters, hasHotSwapSequence, headingAt, hexToRgb255, ignoredPropertyPaths, isCombiningKana, isFullWidth, isPathPolygon, latticeHash, layerCellFootprints, layerCohesion, lerpPathD, lerpSpec, lerpValue, lifeAlphaAt, lifeStaggerAt, linkEdges, linkMaxDistPx, linkPairs, luminanceGrid, manifestFor, morphChainRoot, morphNothingMorphable, motionStats, nextKeyAfter, normalizeSeed, pathFrame, pathParts, perceiveScene, perceiveSequenceFrame, periodWithoutTimeline, pickScreenOp, positionAt, presentWithFinish, readSpecPath, renderBrailleMap, renderDensityMap, resolveSegment, resolveSpecPath, resolveTimelineAt, revealState, rgb255Luma, rotationAt, sceneColour, scenePeriod, seamCauseOf, seamsWorthWarning, segmentRenderSeed, segmentStart, sequenceSteerablePaths, sequenceSwapCompatible, sequenceWantsFinish, sizeAt, spinSymmetry, spriteIndexAt, spriteVariants, steerablePaths, strokeDrawnSamples, strokeLines, structuralSignature, textBlockAnchorOffset, textBlockText, textMetricsClassFor, textSprites, textStringsDiffer, textStringsOf, textWidthEm, timelineFlashReport, timelineLocalTime, timelineSampleTimes, timelineSampleTimesAfter, timelineTracks, trimLines, trimPolyline, validateSequence, validateSpec, validateSpecPaths, wipeMask, withoutTimeline };
+export type { BackgroundDrift, BackgroundSpec, BandSpec, CapabilityTier, CohesionRead, CycleSpec, DominanceEntry, Entity, FieldBackground, FieldDrift, FinishPass, FinishSpec, FlashSamplingForecast, FlattenedPath, GlideEase, GradientStop, IdleSequence, LayerCohesion, LayerGroup, LayerMotionStats, LayerSnapshot, LayerSpec, LayerTransform, LinkEdge, LuminanceGrid, LuminanceGridOptions, MotionEase, MotionSpec, PathGradient, PathGradientStop, PathPart, PathStroke, PerceiveOptions, PerceiveSequenceOptions, PeriodKind, Placed, ResolveOptions, ResolvedPart, ResolvedSegment, RevealState, SaverSpec, SceneColour, SceneDescription, SceneDiff, ScenePerception, ScenePeriod, SceneSnapshot, SchemaExample, ScreenOp, SequenceExample, SequenceFramePerception, SequenceMountContext, SequenceSaverInstance, SequenceSaverPlugin, SequenceSegment, SequenceTransition, SpecError, SpecMountContext, SpecWarning, SpriteSpec, SteerDelta, StrokeDraw, TextBlockAnchor, TextBlockLine, TextMetricsClass, TextNumber, TextRevealInput, TextRevealSpec, TextRole, TextSpriteInfo, Timeline, TimelineFlashReport, TimelineKey, ValidationResult, WanderOsc, WarningBox, WipeTransition };