@rig-c/review 0.7.1 → 0.8.0

package/src/environment-check.ts

@@ -0,0 +1,149 @@
+/**
+ * `POST /api/environment-check` (issue #112): "Check under this world". The Environment block's exported
+ * `rigc-environment/1` schedule is written by review into `<state>/environment-check/<package hash>/<id>/environment.json`,
+ * then `rig-parts check --rig <rig> --out out --parts <handoff parts> --page-edges free --pack-shape polygon
+ * --environment environment.json` runs with the installed producer (@rig-c/parts 1.48.0 or later, parts#538), on the
+ * inspected rig spec (the handoff's, read only) or on the session's latest scratch revision. The pack flags are the
+ * inspected build's own background check's (`src/baseline.ts`), so the default-world line beside it differs only by the
+ * world. The job keeps what check said: its `environment:` line, check.json's `environment` record (path, sha256, steps),
+ * the ANIMATIONS_DO_NOT_FOLD and TEXTURE_STRETCH lines, the summary, and a `CHECK_ENVIRONMENT` refusal verbatim. The
+ * check's output directory is removed after the run; the result is stored so the same schedule on the same build is read
+ * back. The client sends `{build, schedule}` only — never a path or a flag. Nothing is written into the package.
+ */
+import { createHash } from 'node:crypto';
+import { isAbsolute, join, relative } from 'node:path';
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import type { ReviewPackage } from './manifest.ts';
+import { firstRefusal, modelingProducerTooOld, resolveProducer, runTool, versionAtLeast } from './producer.ts';
+import { producerInputs, RebuildError } from './rebuild.ts';
+import { checkSummary, type CheckSummary } from './applied-context.ts';
+import { barLine, READOUT_BARS } from './physics-tuning.ts';
+import { CHECK_ENVIRONMENT_SINCE, parseSchedule, ScheduleError, scheduleText } from './environment-schedule.ts';
+
+export const ENVIRONMENT_CHECK_SCHEMA = 'rig-review-environment-check/1';
+export const ENVIRONMENT_CHECK_LIMIT = 64 * 1024;
+const MAX_LINES = 4000;
+const sha256 = (text: string) => createHash('sha256').update(text).digest('hex');
+const isRecord = (v: unknown): v is Record<string, unknown> => !!v && typeof v === 'object' && !Array.isArray(v);
+
+export class EnvironmentCheckError extends Error { constructor(readonly code: string, detail: string) { super(`${code}: ${detail}`); } }
+export type EnvironmentCheckBuild = 'inspected' | 'scratch';
+export interface EnvironmentCheckRequest { build: EnvironmentCheckBuild; text: string }
+/** `{build, schedule}` only: the schedule as data (re-serialized here, so its hash is the exported bytes'), never a path. */
+export function parseEnvironmentCheckRequest(input: unknown): EnvironmentCheckRequest {
+  if (!isRecord(input) || Object.keys(input).sort().join(',') !== 'build,schedule') throw new EnvironmentCheckError('ENVIRONMENT_CHECK_REQUEST_INVALID', 'expected exactly {build, schedule}');
+  if (input.build !== 'inspected' && input.build !== 'scratch') throw new EnvironmentCheckError('ENVIRONMENT_CHECK_REQUEST_INVALID', 'build must be inspected or scratch');
+  try { return { build: input.build, text: scheduleText(parseSchedule(input.schedule)) }; }
+  catch (e) { if (e instanceof ScheduleError) throw new EnvironmentCheckError('ENVIRONMENT_CHECK_REQUEST_INVALID', e.message); throw e; }
+}
+/** check's argv as `rig-parts check --help` states it (1.48.0); every path the server's. */
+export const environmentCheckArgs = (r: { rig: string; parts: string; out: string; environment: string }): string[] =>
+  ['check', '--rig', r.rig, '--out', r.out, '--parts', r.parts, '--page-edges', 'free', '--pack-shape', 'polygon', '--environment', r.environment];
+
+/** What check.json records under `--environment` (parts#538): the path as given, the bytes' sha256, the step count. */
+export interface CheckEnvironmentRecord { path: string; sha256: string; steps: number }
+export function checkEnvironmentRecord(checkJson: unknown): CheckEnvironmentRecord | null {
+  const e = isRecord(checkJson) && isRecord(checkJson.environment) ? checkJson.environment : null;
+  return e && typeof e.path === 'string' && typeof e.sha256 === 'string' && Number.isSafeInteger(e.steps) ? { path: e.path, sha256: e.sha256, steps: e.steps as number } : null;
+}
+/** check's `environment: <path>, rigc-environment/1, <n> step(s), sha256 <16 hex> — …` line, verbatim (trimmed). */
+export const environmentLineOf = (lines: readonly string[]) => lines.map(l => l.trim()).find(l => /^environment: \S.*rigc-environment\/1, \d+ step\(s\), sha256 [0-9a-f]{16}/.test(l)) ?? null;
+
+export interface EnvironmentCheckJob {
+  schema: typeof ENVIRONMENT_CHECK_SCHEMA; id: string; status: 'running' | 'checked' | 'refused' | 'failed';
+  build: EnvironmentCheckBuild; buildId: string | null;
+  /** The schedule as written: its sha256, byte length, step count. */
+  schedule: { sha256: string; size: number; steps: number };
+  producer: { package: string; version: string };
+  exitCode: number | null; wallMs: number | null;
+  check: CheckSummary | null;
+  /** check.json's `environment`; its sha256 must be the schedule's (a mismatch fails the job). */
+  environment: CheckEnvironmentRecord | null;
+  environmentLine: string | null;
+  /** The readout bars' lines (ANIMATIONS_DO_NOT_FOLD, TEXTURE_STRETCH) as check printed them. */
+  bars: { name: string; line: string }[];
+  /** A named refusal verbatim (`FAIL  CHECK_ENVIRONMENT: …`), or why the run failed. */
+  error: string | null;
+  lines: string[];
+}
+export interface EnvironmentCheckOptions {
+  stateDir: string; starts: readonly string[]; unchanged: () => Promise<void>;
+  latest: () => { id: string; spec: string } | null;
+}
+export const environmentCheckRoot = (stateDir: string, sourceHash: string) => join(stateDir, 'environment-check', sourceHash);
+
+/** One check at a time per review instance; finished jobs stay readable by id, and a stored result is read back. */
+export function createEnvironmentCheck(p: ReviewPackage, options: EnvironmentCheckOptions) {
+  const jobs = new Map<string, EnvironmentCheckJob>();
+  let running: string | null = null;
+  const snapshot = (job: EnvironmentCheckJob): EnvironmentCheckJob => JSON.parse(JSON.stringify(job)) as EnvironmentCheckJob;
+  function assertStateOutside(): void {
+    for (const root of [p.root, ...(p.handoff ? [p.handoff.root] : [])]) {
+      const inside = relative(root, options.stateDir);
+      if (inside === '' || !inside.startsWith('..') && !isAbsolute(inside)) throw new EnvironmentCheckError('ENVIRONMENT_CHECK_STATE_INSIDE_PACKAGE', 'the review state directory is inside the inspected package; set RIG_REVIEW_STATE_DIR outside it');
+    }
+  }
+
+  async function execute(job: EnvironmentCheckJob, dir: string, bin: string, rig: string, parts: string, text: string): Promise<void> {
+    try {
+      await rm(dir, { recursive: true, force: true });
+      await mkdir(dir, { recursive: true, mode: 0o700 });
+      await writeFile(join(dir, 'environment.json'), text, { mode: 0o600 });
+      const run = await runTool(bin, environmentCheckArgs({ rig, parts, out: 'out', environment: 'environment.json' }), { cwd: dir, onLine: line => { if (job.lines.length < MAX_LINES) job.lines.push(line); } });
+      let checkJson: unknown = null;
+      try { checkJson = JSON.parse(await readFile(join(dir, 'out', 'check.json'), 'utf8')); } catch { /* refused before check.json; the lines say why */ }
+      const refusal = firstRefusal(run.lines);
+      Object.assign(job, { exitCode: run.exitCode, wallMs: run.wallMs, environmentLine: environmentLineOf(run.lines), environment: checkEnvironmentRecord(checkJson) });
+      try { await options.unchanged(); } catch { throw new EnvironmentCheckError('ENVIRONMENT_CHECK_INPUTS_CHANGED', 'the package or its producer handoff changed during the check'); }
+      if (checkJson === null) { job.status = 'refused'; job.error = refusal ?? `rig-parts check exited ${run.exitCode} without a named refusal`; }
+      else {
+        job.check = checkSummary(checkJson, run.exitCode, run.lines, refusal);
+        job.bars = READOUT_BARS.map(name => ({ name, line: barLine(name, run.lines, job.check) }));
+        if (!job.environment || job.environment.sha256 !== job.schedule.sha256) throw new EnvironmentCheckError('ENVIRONMENT_CHECK_UNRECORDED', `check.json's environment ${job.environment ? `sha256 ${job.environment.sha256}` : 'is absent'}; the schedule written was sha256 ${job.schedule.sha256}`);
+        job.status = 'checked';
+      }
+      await writeFile(join(dir, 'result.json'), JSON.stringify({ ...job, lines: job.lines.slice(-MAX_LINES) }, null, 1) + '\n', { mode: 0o600 });
+    } catch (error) { job.status = 'failed'; job.error = error instanceof Error ? error.message : String(error); }
+    finally { await rm(join(dir, 'out'), { recursive: true, force: true }).catch(() => {}); if (job.status === 'failed') await rm(dir, { recursive: true, force: true }).catch(() => {}); }
+  }
+
+  /** Refusals before anything runs; a malformed request is ENVIRONMENT_CHECK_REQUEST_INVALID (400 at the route). */
+  async function start(input: unknown): Promise<{ status: number; body: unknown }> {
+    const request = parseEnvironmentCheckRequest(input);
+    assertStateOutside();
+    await options.unchanged();
+    let inputs: Awaited<ReturnType<typeof producerInputs>>;
+    try { inputs = await producerInputs(p.handoff, p.handoffReason); } catch (e) { if (e instanceof RebuildError) return { status: 200, body: { status: 'refused', error: e.message } }; throw e; }
+    let rig = inputs.rig, buildId: string | null = null;
+    if (request.build === 'scratch') {
+      const latest = options.latest();
+      if (!latest) return { status: 200, body: { status: 'refused', error: 'ENVIRONMENT_CHECK_NO_SCRATCH: no scratch build in this session yet; Apply builds one, or check the inspected rig' } };
+      rig = latest.spec; buildId = latest.id;
+    }
+    const resolved = resolveProducer(options.starts);
+    if (!resolved.ok) return { status: 200, body: { status: 'refused', error: resolved.error } };
+    const producer = { package: resolved.producer.package, version: resolved.producer.version };
+    if (!versionAtLeast(producer.version, CHECK_ENVIRONMENT_SINCE)) return { status: 200, body: { status: 'refused', error: modelingProducerTooOld(producer.version || 'unknown', CHECK_ENVIRONMENT_SINCE, 'rig-parts check --environment') } };
+    const fileSha = sha256(request.text);
+    const id = sha256(JSON.stringify([ENVIRONMENT_CHECK_SCHEMA, p.sourceHash, fileSha, request.build, buildId, inputs.configHash, `${producer.package}@${producer.version}`]));
+    const current = jobs.get(id);
+    if (current && current.status !== 'failed') return { status: current.status === 'running' ? 202 : 200, body: snapshot(current) };
+    const dir = join(environmentCheckRoot(options.stateDir, p.sourceHash), id);
+    try { const stored = JSON.parse(await readFile(join(dir, 'result.json'), 'utf8')) as EnvironmentCheckJob; if (stored.schema === ENVIRONMENT_CHECK_SCHEMA && stored.id === id) { jobs.set(id, stored); return { status: 200, body: snapshot(stored) }; } } catch { /* not run yet */ }
+    if (running) return { status: 200, body: { status: 'refused', error: `ENVIRONMENT_CHECK_BUSY: check ${running} is still running` } };
+    const job: EnvironmentCheckJob = {
+      schema: ENVIRONMENT_CHECK_SCHEMA, id, status: 'running', build: request.build, buildId,
+      schedule: { sha256: fileSha, size: Buffer.byteLength(request.text), steps: (JSON.parse(request.text) as { steps: unknown[] }).steps.length }, producer,
+      exitCode: null, wallMs: null, check: null, environment: null, environmentLine: null, bars: [], error: null, lines: [],
+    };
+    jobs.set(id, job); running = id;
+    void execute(job, dir, resolved.producer.bin, rig, inputs.parts, request.text).finally(() => { if (running === id) running = null; });
+    return { status: 202, body: snapshot(job) };
+  }
+  function read(id: string): EnvironmentCheckJob {
+    const job = jobs.get(id);
+    if (!job) throw new EnvironmentCheckError('ENVIRONMENT_CHECK_NOT_FOUND', id);
+    return snapshot(job);
+  }
+  return { start, read, running: () => running };
+}

package/src/environment-schedule.ts

@@ -0,0 +1,183 @@
+/**
+ * The Environment block's wind as a `rigc-environment/1` schedule (issue #112): what `rigc render --environment` and
+ * `rig-parts check --environment` (@rig-c/parts 1.48.0, parts#538) read — `{spec, steps: [{t, wind?, gravity?}]}`, each
+ * step holding from its `t` until the next, x right and y down, the runtime's wind [1, 0] and gravity [0, 1] before the
+ * first. Pure: no DOM, no IO, no clock.
+ *
+ * The panel's wind (`./environment.ts`) is `base + breeze(t) + gust(t)` on a clock the player's steps advance. From a
+ * fresh clock (`restore`, which starts a repeating gust at 0) that is a function of time alone, so a schedule can carry
+ * it with t = 0 at the animation's first frame:
+ *  - the step form (no breeze, no repeating gust): one step, the standing world — exact;
+ *  - the sampled form (breeze and/or repeat on): one step per frame of the render's grid (`SCHEDULE_FPS`), each the
+ *    panel's wind at that frame's time. rigc sets a step before the physics step that poses its frame, as the panel sets
+ *    the wind before the player's step, so the two agree at every frame time; between frames rigc holds the frame's
+ *    value, within `scheduleTolerance` of the panel's.
+ * A one-off Gust (Repeat off) is an event on the live clock, not part of the settings, and is not in the schedule.
+ */
+import { breezeAt, gustEnvelope, gustPeriod, type WindSnapshot } from './environment.ts';
+
+export const ENVIRONMENT_SPEC = 'rigc-environment/1';
+/** The grid the schedule is sampled on: `rigc render`'s default fps and `rig-parts check`'s IDLE_FPS. */
+export const SCHEDULE_FPS = 12;
+/** At most this many steps (50 s at 12 fps, ~36 KiB of JSON); a longer clip is refused by name. */
+export const MAX_SCHEDULE_STEPS = 600;
+/** The first `@rig-c/parts` release whose `check` reads `--environment` (its CHANGELOG: 1.48.0, parts#538). */
+export const CHECK_ENVIRONMENT_SINCE = '1.48.0';
+/** The runtime's world before the first step (rig-c `src/environment.ts`). */
+export const RUNTIME_WORLD = { wind: [1, 0] as [number, number], gravity: [0, 1] as [number, number] };
+
+export interface EnvironmentStep { t: number; wind?: [number, number]; gravity?: [number, number] }
+export interface EnvironmentSchedule { spec: typeof ENVIRONMENT_SPEC; steps: EnvironmentStep[] }
+export class ScheduleError extends Error { constructor(readonly code: string, detail: string) { super(`${code}: ${detail}`); } }
+
+/** The standing world as one step from t = 0 (#108's readings schedule; the step form below is this). */
+export const standingSchedule = (e: { wind: [number, number]; gravity: [number, number] }): EnvironmentSchedule => ({ spec: ENVIRONMENT_SPEC, steps: [{ t: 0, wind: e.wind, gravity: e.gravity }] });
+
+/** The panel's wind at clock time `t` from a fresh clock (`createWindModel().restore(snapshot)`, then advanced to `t`). */
+export function windAt(s: WindSnapshot, t: number): number {
+  const gentle = s.breeze ? breezeAt(t) : 0;
+  let gust = 0;
+  if (s.repeat) {
+    const period = gustPeriod(s.gustDuration), age = t - Math.floor(t / period) * period;
+    gust = (s.base < 0 ? -1 : 1) * gustEnvelope(age, s.gustPeak, s.gustDuration);
+  }
+  return s.base + gentle + gust;
+}
+/** Whether the wind changes in time (breeze or a repeating gust): the sampled form. */
+export const windVaries = (s: WindSnapshot) => s.breeze || (s.repeat && s.gustPeak > 0);
+/**
+ * The largest difference between the panel's wind and the schedule's held value inside one frame interval:
+ * max |dw/dt| / fps, with |breeze'| <= 2·2.2 + 0.8·5.1 and |gust'| <= peak·π / duration. 0 for the step form.
+ */
+export function scheduleTolerance(s: WindSnapshot, fps = SCHEDULE_FPS): number {
+  if (!windVaries(s)) return 0;
+  return ((s.breeze ? 2 * 2.2 + 0.8 * 5.1 : 0) + (s.repeat ? s.gustPeak * Math.PI / s.gustDuration : 0)) / fps;
+}
+
+export type ScheduleForm = 'step' | 'sampled';
+export interface WindScheduleExport { schedule: EnvironmentSchedule; form: ScheduleForm; tolerance: number; fps: number; duration: number }
+/**
+ * The panel's settings and gravity (the slider's value, applied as [0, g]) as a schedule over a clip of `duration`
+ * seconds: the step form when nothing varies, else one step per frame of `fps` up to the clip's last frame (rigc refuses a
+ * step after it), a step whose wind equals the one before left out.
+ */
+export function windSchedule(s: WindSnapshot, gravity: number, duration: number, fps = SCHEDULE_FPS): WindScheduleExport {
+  const g: [number, number] = [0, gravity];
+  if (!windVaries(s)) return { schedule: standingSchedule({ wind: [s.base, 0], gravity: g }), form: 'step', tolerance: 0, fps, duration };
+  if (!(duration > 0) || !Number.isFinite(duration)) throw new ScheduleError('ENVIRONMENT_SCHEDULE_NO_CLIP', 'a breeze or a repeating gust is sampled over a clip; no clip with a duration is drawn');
+  const last = Math.round(duration * fps);
+  if (last + 1 > MAX_SCHEDULE_STEPS) throw new ScheduleError('ENVIRONMENT_SCHEDULE_TOO_LONG', `${duration} s at ${fps} fps is ${last + 1} steps; at most ${MAX_SCHEDULE_STEPS}`);
+  const steps: EnvironmentStep[] = [];
+  let previous = NaN;
+  for (let k = 0; k <= last; k++) {
+    const t = k / fps, w = windAt(s, t);
+    if (k === 0) steps.push({ t, wind: [w, 0], gravity: g });
+    else if (w !== previous) steps.push({ t, wind: [w, 0] });
+    previous = w;
+  }
+  return { schedule: { spec: ENVIRONMENT_SPEC, steps }, form: 'sampled', tolerance: scheduleTolerance(s, fps), fps, duration };
+}
+
+/** The exported bytes: what is downloaded, written for rigc and rig-parts, and hashed into feedback. */
+export const scheduleText = (s: EnvironmentSchedule) => JSON.stringify(s, null, 1) + '\n';
+
+const bad = (detail: string): never => { throw new ScheduleError('ENVIRONMENT_SCHEDULE_INVALID', detail); };
+const isRecord = (v: unknown): v is Record<string, unknown> => !!v && typeof v === 'object' && !Array.isArray(v);
+const pair = (v: unknown, field: string): [number, number] => {
+  if (!Array.isArray(v) || v.length !== 2 || !v.every(n => typeof n === 'number' && Number.isFinite(n) && Math.abs(n) <= 1e4)) bad(`${field} must be [x, y], finite`);
+  return [(v as number[])[0]!, (v as number[])[1]!];
+};
+/** A schedule as rig-c's reader takes it (exact keys, ascending t from 0, a half stated per step), bounded; data only. */
+export function parseSchedule(value: unknown): EnvironmentSchedule {
+  if (!isRecord(value) || Object.keys(value).sort().join(',') !== 'spec,steps') return bad('expected exactly {spec, steps}');
+  if (value.spec !== ENVIRONMENT_SPEC) bad(`spec must be ${ENVIRONMENT_SPEC}`);
+  if (!Array.isArray(value.steps) || value.steps.length < 1 || value.steps.length > MAX_SCHEDULE_STEPS) bad(`steps must hold 1–${MAX_SCHEDULE_STEPS} entries`);
+  const steps: EnvironmentStep[] = [];
+  (value.steps as unknown[]).forEach((raw, i) => {
+    if (!isRecord(raw) || !Object.keys(raw).every(k => k === 't' || k === 'wind' || k === 'gravity')) bad(`steps[${i}] holds only t, wind, gravity`);
+    const step = raw as Record<string, unknown>, t = step.t;
+    if (typeof t !== 'number' || !Number.isFinite(t) || t < 0 || t > 3600) bad(`steps[${i}].t must be seconds in [0, 3600]`);
+    if (i > 0 && !((t as number) > steps[i - 1]!.t)) bad(`steps[${i}].t must come after steps[${i - 1}].t`);
+    if (step.wind === undefined && step.gravity === undefined) bad(`steps[${i}] states neither wind nor gravity`);
+    steps.push({ t: t as number, ...(step.wind === undefined ? {} : { wind: pair(step.wind, `steps[${i}].wind`) }), ...(step.gravity === undefined ? {} : { gravity: pair(step.gravity, `steps[${i}].gravity`) }) });
+  });
+  return { spec: ENVIRONMENT_SPEC, steps };
+}
+
+/** rig-c's `environmentFrame`: the first frame `i` whose time `i / fps` is at or after `t`. */
+export function environmentFrame(t: number, fps: number): number {
+  let i = Math.max(0, Math.ceil(t * fps));
+  while (i > 0 && (i - 1) / fps >= t) i--;
+  while (i / fps < t) i++;
+  return i;
+}
+/**
+ * The world as rigc reads the schedule at time `t` on the `fps` grid: the physics step that ends on frame
+ * `environmentFrame(t)` runs under every step that lands on that frame or before (the runtime's world before the first).
+ */
+export function scheduleWorldAt(s: EnvironmentSchedule, t: number, fps = SCHEDULE_FPS): { wind: [number, number]; gravity: [number, number] } {
+  const frame = environmentFrame(t, fps);
+  let wind = RUNTIME_WORLD.wind, gravity = RUNTIME_WORLD.gravity;
+  for (const step of s.steps) { if (environmentFrame(step.t, fps) > frame) break; if (step.wind) wind = step.wind; if (step.gravity) gravity = step.gravity; }
+  return { wind, gravity };
+}
+
+/** One line: form, steps, the hash's first 16 hex (as check's `environment:` line prints it), the tolerance. */
+export function scheduleSummary(e: WindScheduleExport, sha256: string): string {
+  const form = e.form === 'step' ? 'step form (exact)' : `sampled at ${e.fps} fps over ${e.duration.toFixed(3)} s (held between frames, within ${e.tolerance.toFixed(3)} of the panel)`;
+  return `${ENVIRONMENT_SPEC}, ${e.schedule.steps.length} step(s), sha256 ${sha256.slice(0, 16)} · ${form}`;
+}
+
+/** `context.environmentSchedule` (#112): the exported bytes by hash and content, and whether readings and Apply used them. */
+export const SCHEDULE_CONTEXT_SCHEMA = 'rig-review-environment-schedule/1';
+export interface ScheduleContext { schema: typeof SCHEDULE_CONTEXT_SCHEMA; sha256: string; size: number; text: string; usedForReadings: boolean }
+const ctx = (detail: string): never => { throw new Error(`feedback.context.environmentSchedule: ${detail}`); };
+/** The context's exact shape, its sha256 recomputed over `text` (`hash` is the caller's) and `text` a schedule. */
+export function parseScheduleContext(value: unknown, hash: (text: string) => string): ScheduleContext | null {
+  if (value === null) return null;
+  if (!isRecord(value) || Object.keys(value).sort().join(',') !== 'schema,sha256,size,text,usedForReadings') return ctx('expected exactly {schema, sha256, size, text, usedForReadings}');
+  if (value.schema !== SCHEDULE_CONTEXT_SCHEMA) ctx(`schema must be ${SCHEDULE_CONTEXT_SCHEMA}`);
+  if (typeof value.text !== 'string' || value.text.length > 128 * 1024) ctx('text must be the exported schedule, at most 128 KiB');
+  const text = value.text as string;
+  if (typeof value.sha256 !== 'string' || value.sha256 !== hash(text)) ctx('sha256 is not the sha256 of text');
+  if (value.size !== new TextEncoder().encode(text).length) ctx('size is not the byte length of text');
+  if (typeof value.usedForReadings !== 'boolean') ctx('usedForReadings must be a boolean');
+  let doc: unknown;
+  try { doc = JSON.parse(text); } catch { return ctx('text does not parse as JSON'); }
+  try { parseSchedule(doc); } catch (e) { ctx(`text is not a ${ENVIRONMENT_SPEC} schedule (${e instanceof Error ? e.message : String(e)})`); }
+  return value as unknown as ScheduleContext;
+}
+/** "41 step(s) · sha256 … · used for readings": one line for the issue export. */
+export function scheduleContextLine(value: unknown): string | null {
+  if (!isRecord(value) || value.schema !== SCHEDULE_CONTEXT_SCHEMA || typeof value.sha256 !== 'string' || typeof value.text !== 'string') return null;
+  let steps = 0;
+  try { const doc = JSON.parse(value.text) as { steps?: unknown[] }; steps = Array.isArray(doc.steps) ? doc.steps.length : 0; } catch { return null; }
+  return `${ENVIRONMENT_SPEC}, ${steps} step(s) · schedule sha256 ${value.sha256}${value.usedForReadings ? ' · used for readings and Apply' : ' · not used for readings'}`;
+}
+
+/** SHA-256 of a string's UTF-8 bytes, hex — synchronous, so the page can hash the exported bytes where it records them. */
+export function sha256Hex(text: string): string {
+  const bytes = new TextEncoder().encode(text), K = new Uint32Array([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2]);
+  const h = new Uint32Array([0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19]);
+  const length = Math.ceil((bytes.length + 9) / 64) * 64, m = new Uint8Array(length);
+  m.set(bytes); m[bytes.length] = 0x80;
+  const view = new DataView(m.buffer), bits = bytes.length * 8;
+  view.setUint32(length - 8, Math.floor(bits / 0x100000000)); view.setUint32(length - 4, bits >>> 0);
+  const w = new Uint32Array(64), rot = (x: number, n: number) => (x >>> n) | (x << (32 - n));
+  for (let o = 0; o < length; o += 64) {
+    for (let i = 0; i < 16; i++) w[i] = view.getUint32(o + i * 4);
+    for (let i = 16; i < 64; i++) { const a = w[i - 15]!, b = w[i - 2]!; w[i] = (w[i - 16]! + (rot(a, 7) ^ rot(a, 18) ^ (a >>> 3)) + w[i - 7]! + (rot(b, 17) ^ rot(b, 19) ^ (b >>> 10))) >>> 0; }
+    let [a, b, c, d, e, f, g, hh] = h as unknown as number[];
+    for (let i = 0; i < 64; i++) {
+      const t1 = (hh! + (rot(e!, 6) ^ rot(e!, 11) ^ rot(e!, 25)) + ((e! & f!) ^ (~e! & g!)) + K[i]! + w[i]!) >>> 0;
+      const t2 = ((rot(a!, 2) ^ rot(a!, 13) ^ rot(a!, 22)) + ((a! & b!) ^ (a! & c!) ^ (b! & c!))) >>> 0;
+      hh = g; g = f; f = e; e = (d! + t1) >>> 0; d = c; c = b; b = a; a = (t1 + t2) >>> 0;
+    }
+    h[0] += a!; h[1] += b!; h[2] += c!; h[3] += d!; h[4] += e!; h[5] += f!; h[6] += g!; h[7] += hh!;
+  }
+  return [...h].map(x => x.toString(16).padStart(8, '0')).join('');
+}

package/src/feedback-export.ts

@@ -7,6 +7,7 @@ import type { ReferenceBinding } from './reference.ts';
 import { environmentSummary, parseEnvironmentContext } from './environment.ts';
 import { appliedSummary } from './applied-context.ts';
 import { requirementsSummaryLine } from './requirements.ts';
+import { scheduleContextLine } from './environment-schedule.ts';
 type Category = Feedback['category'];
 type Side = 'single' | 'a' | 'b';
 type ParsedFeedbackSession = FeedbackHistory<ReviewSession | CompareSession>;
@@ -176,6 +177,12 @@ function requirementsLine(context: Json | undefined): string[] {
   const text = requirementsSummaryLine(context.requirements);
   return text === null ? [] : [`- Requirements: ${feedbackMarkdownText(text)}`];
 }
+/** "Environment schedule: rigc-environment/1, 41 step(s) · schedule sha256 …": the exported world the note carries (#112). */
+function scheduleLine(context: Json | undefined): string[] {
+  if (context === undefined || context === null || typeof context !== 'object' || Array.isArray(context) || !('environmentSchedule' in context)) return [];
+  const text = scheduleContextLine(context.environmentSchedule);
+  return text === null ? [] : [`- Environment schedule: ${feedbackMarkdownText(text)}`];
+}
 /** Local issue-ready text only. No issue creation, clock inference or source IO. */
 export function formatFeedbackIssues(input: ParsedFeedbackSession): string {
   const model = groupFeedbackIssues(input), md = feedbackMarkdownText;
@@ -209,7 +216,7 @@ export function formatFeedbackIssues(input: ParsedFeedbackSession): string {
           `- Summary: ${md(item.summary)}`,
           ...environmentLine(item.context),
           ...appliedLine(item.context),
-          ...requirementsLine(item.context), '',
+          ...requirementsLine(item.context), ...scheduleLine(item.context), '',
           'Selected build identity:', '', jsonBlock(item.selectedSource));
         if (model.pairedBinding) lines.push('', 'Paired comparison binding:', '', jsonBlock(model.pairedBinding));
         if (item.warnings.length) lines.push('', 'Validation warnings (record retained):', '', jsonBlock(item.warnings));

package/src/front.ts

@@ -61,11 +61,14 @@ export function frontRoute(mode:'single'|'compare',method:string,path:string):Ro
  // Bones check (#109, single only): one typed request {ops, configHash}, answered in the response.
  if(mode==='single'&&path==='/api/bones-check')return method==='POST'?{mutation:true,limit:64*1024,timeoutMs:60000,control:false}:null;
  // Readings (#108, single only): one typed request, then its job's status.
- if(mode==='single'&&path==='/api/readings')return method==='POST'?{mutation:true,limit:16*1024,timeoutMs:30000,control:false}:null;
+ if(mode==='single'&&path==='/api/readings')return method==='POST'?{mutation:true,limit:64*1024,timeoutMs:30000,control:false}:null;
  if(mode==='single'&&/^\/api\/readings\/[a-f0-9]{64}$/.test(path))return read?get:null;
  // Declared requirements (#113, single only): the stage's catalog, one typed request, then its job's status.
  if(mode==='single'&&path==='/api/requirements')return read?get:method==='POST'?{mutation:true,limit:64*1024,timeoutMs:30000,control:false}:null;
  if(mode==='single'&&/^\/api\/requirements\/[a-f0-9]{64}$/.test(path))return read?get:null;
+ // Check under this world (#112, single only): one typed request {build, schedule}, then its job's status.
+ if(mode==='single'&&path==='/api/environment-check')return method==='POST'?{mutation:true,limit:64*1024,timeoutMs:30000,control:false}:null;
+ if(mode==='single'&&/^\/api\/environment-check\/[a-f0-9]{64}$/.test(path))return read?get:null;
  return null;
 }
 async function boundedBody(req:Request,limit:number,timeoutMs=10000):Promise<ArrayBuffer>{

package/src/handoff.ts

@@ -25,9 +25,9 @@ export const CONFIG_NAMED_FILES = [['motion', 'animations_from'], ['generation',
 export const RIG_FILES = ['rig.json', 'motion.json', 'mesh_report.json'] as const;
 const MAX_LISTED = 4096;
 
-export interface HandoffDeclaration { config: string; parts?: string; source?: string; full?: string; head?: string }
+export interface HandoffDeclaration { config: string; parts?: string; source?: string; full?: string; head?: string; keypoints?: string }
 export type HandoffFlags = HandoffDeclaration;
-export const HANDOFF_FLAGS = ['config', 'parts', 'source', 'full', 'head'] as const;
+export const HANDOFF_FLAGS = ['config', 'parts', 'source', 'full', 'head', 'keypoints'] as const;
 export interface HandoffFile { path: string; sha256: string }
 /** The identity record: paths relative to the package root (`../` only for the discovered parent config), every hashed file. */
 export interface HandoffRecord {
@@ -37,13 +37,16 @@ export interface HandoffRecord {
   outside: boolean;
   config: HandoffFile;
   parts: string | null; rig: string | null; source: HandoffFile | null; full: string | null; head: string | null;
+  /** #111: the declared body-18 keypoint file `rig-parts propose --keypoints` reads; the key is absent when none is declared, so an undeclared handoff's identity is unchanged. */
+  keypoints?: HandoffFile;
   files: HandoffFile[];
   missing: string[];
 }
 /** The record plus the absolute paths the producer is run with (never served, never in the identity). */
 /** `source` (#109): the declared source painting's absolute path, which `propose --from-config` reads; null when none was declared. */
 /** `full` / `head` (#115): the declared See-through runs' absolute paths, which `rig-parts build` reads; null when none was declared. */
-export interface Handoff { record: HandoffRecord; config: string; parts: string | null; rig: string | null; root: string; flags?: HandoffFlags; source?: string | null; full?: string | null; head?: string | null }
+/** `keypoints` (#111): the declared keypoint file's absolute path, which a cloth recipe Apply's `propose --keypoints` reads; null when none was declared. */
+export interface Handoff { record: HandoffRecord; config: string; parts: string | null; rig: string | null; root: string; flags?: HandoffFlags; source?: string | null; full?: string | null; head?: string | null; keypoints?: string | null }
 
 export class HandoffError extends Error {
   constructor(readonly code: string, readonly field: string, readonly detail: string) { super(`${code} ${field}: ${detail}`); }
@@ -87,15 +90,15 @@ async function blockPath(root: string, value: unknown, field: string, kind: 'fil
   return contained(root, join(root, value), field, kind, true);
 }
 
-/** `producer: {config, parts?, source?, full?, head?}` — strings only, no other key. Paths are checked at load. */
+/** `producer: {config, parts?, source?, full?, head?, keypoints?}` — strings only, no other key. Paths are checked at load. */
 export function parseHandoffDeclaration(value: unknown): HandoffDeclaration | undefined {
   if (value === undefined) return undefined;
-  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new HandoffError('HANDOFF_PATH_INVALID', 'producer', 'expected an object {config, parts?, source?, full?, head?}');
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new HandoffError('HANDOFF_PATH_INVALID', 'producer', 'expected an object {config, parts?, source?, full?, head?, keypoints?}');
   const v = value as Record<string, unknown>;
-  for (const key of Object.keys(v)) if (!(HANDOFF_FLAGS as readonly string[]).includes(key)) throw new HandoffError('HANDOFF_PATH_INVALID', `producer.${key}`, 'unknown key; expected config, parts, source, full, head');
+  for (const key of Object.keys(v)) if (!(HANDOFF_FLAGS as readonly string[]).includes(key)) throw new HandoffError('HANDOFF_PATH_INVALID', `producer.${key}`, 'unknown key; expected config, parts, source, full, head, keypoints');
   if (typeof v.config !== 'string') throw new HandoffError('HANDOFF_PATH_INVALID', 'producer.config', 'required: the producer config path');
   const out: HandoffDeclaration = { config: v.config };
-  for (const key of ['parts', 'source', 'full', 'head'] as const) if (v[key] !== undefined) { if (typeof v[key] !== 'string') throw new HandoffError('HANDOFF_PATH_INVALID', `producer.${key}`, 'expected a string path'); out[key] = v[key] as string; }
+  for (const key of ['parts', 'source', 'full', 'head', 'keypoints'] as const) if (v[key] !== undefined) { if (typeof v[key] !== 'string') throw new HandoffError('HANDOFF_PATH_INVALID', `producer.${key}`, 'expected a string path'); out[key] = v[key] as string; }
   return out;
 }
 /** `--source` and `--full` travel together, `--head` only with them, and everything else only with `--config`. */
@@ -119,7 +122,7 @@ async function listed(base: string, dir: string, field: string): Promise<string[
 }
 
 /** Hash every handoff file and build the record. `root` is the package root (display paths are relative to it). */
-async function record(root: string, base: string, how: HandoffRecord['how'], via: HandoffRecord['via'], config: string, partsPath: string | null, extra: { source?: string; full?: string; head?: string }, partsDeclared: boolean): Promise<Handoff> {
+async function record(root: string, base: string, how: HandoffRecord['how'], via: HandoffRecord['via'], config: string, partsPath: string | null, extra: { source?: string; full?: string; head?: string; keypoints?: string }, partsDeclared: boolean): Promise<Handoff> {
   const show = (path: string) => relative(root, path).split(sep).join('/') || '.';
   const files = new Map<string, string>(), missing: string[] = [];
   const add = async (path: string) => { files.set(show(path), await hashFile(path)); };
@@ -154,10 +157,12 @@ async function record(root: string, base: string, how: HandoffRecord['how'], via
   let source: HandoffFile | null = null;
   if (extra.source) { await add(extra.source); source = { path: show(extra.source), sha256: files.get(show(extra.source))! }; }
   for (const dir of [extra.full, extra.head]) if (dir) for (const file of await listed(base, dir, show(dir))) await add(file);
+  // #111: hashed only when declared — an undeclared handoff's record (and so its identity) holds no keypoints key at all.
+  if (extra.keypoints) await add(extra.keypoints);
   const sorted = [...files].sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)).map(([path, hash]) => ({ path, sha256: hash }));
   return {
-    record: { schema: HANDOFF_SCHEMA, how, via, outside: !inside(root, config), config: { path: show(config), sha256: files.get(show(config))! }, parts: parts ? show(parts) : null, rig: rig ? show(rig) : null, source, full: extra.full ? show(extra.full) : null, head: extra.head ? show(extra.head) : null, files: sorted, missing },
-    config, parts, rig, root: base, source: extra.source ?? null, full: extra.full ?? null, head: extra.head ?? null,
+    record: { schema: HANDOFF_SCHEMA, how, via, outside: !inside(root, config), config: { path: show(config), sha256: files.get(show(config))! }, parts: parts ? show(parts) : null, rig: rig ? show(rig) : null, source, full: extra.full ? show(extra.full) : null, head: extra.head ? show(extra.head) : null, ...(extra.keypoints ? { keypoints: { path: show(extra.keypoints), sha256: files.get(show(extra.keypoints))! } } : {}), files: sorted, missing },
+    config, parts, rig, root: base, source: extra.source ?? null, full: extra.full ?? null, head: extra.head ?? null, keypoints: extra.keypoints ?? null,
   };
 }
 
@@ -175,9 +180,10 @@ export async function resolveHandoff(root: string, declared: HandoffDeclaration
     const source = flags.source !== undefined ? await flagPath(root, flags.source, '--source', 'file') : undefined;
     const full = flags.full !== undefined ? await flagPath(root, flags.full, '--full', 'dir') : undefined;
     const head = flags.head !== undefined ? await flagPath(root, flags.head, '--head', 'dir') : undefined;
-    const handoff = await record(root, root, 'declared', 'open --config', config, parts, { source, full, head }, flags.parts !== undefined);
+    const keypoints = flags.keypoints !== undefined ? await flagPath(root, flags.keypoints, '--keypoints', 'file') : undefined;
+    const handoff = await record(root, root, 'declared', 'open --config', config, parts, { source, full, head, keypoints }, flags.parts !== undefined);
     // Canonical absolute flags: the background worker and later reloads read exactly these.
-    handoff.flags = { config, ...(flags.parts !== undefined ? { parts } : {}), ...(source ? { source } : {}), ...(full ? { full } : {}), ...(head ? { head } : {}) };
+    handoff.flags = { config, ...(flags.parts !== undefined ? { parts } : {}), ...(source ? { source } : {}), ...(full ? { full } : {}), ...(head ? { head } : {}), ...(keypoints ? { keypoints } : {}) };
     return { handoff, reason: null };
   }
   if (declared) {
@@ -186,8 +192,9 @@ export async function resolveHandoff(root: string, declared: HandoffDeclaration
     const source = declared.source !== undefined ? await blockPath(root, declared.source, 'producer.source', 'file') : undefined;
     const full = declared.full !== undefined ? await blockPath(root, declared.full, 'producer.full', 'dir') : undefined;
     const head = declared.head !== undefined ? await blockPath(root, declared.head, 'producer.head', 'dir') : undefined;
+    const keypoints = declared.keypoints !== undefined ? await blockPath(root, declared.keypoints, 'producer.keypoints', 'file') : undefined;
     if ((source === undefined) !== (full === undefined) || (head !== undefined && full === undefined)) throw new HandoffError('HANDOFF_FLAGS_INVALID', 'producer', 'source and full are given together, head only with them');
-    return { handoff: await record(root, root, 'declared', 'review.json producer', config, parts, { source, full, head }, declared.parts !== undefined), reason: null };
+    return { handoff: await record(root, root, 'declared', 'review.json producer', config, parts, { source, full, head, keypoints }, declared.parts !== undefined), reason: null };
   }
   for (const name of ['config.json', 'rig/config.json']) {
     const path = join(root, name);

package/src/open.ts

@@ -18,7 +18,7 @@ import {ensureFront,frontPort} from './front.ts';
 import {playPackagePath} from './versions.ts';
 import {HandoffError,HANDOFF_FLAGS,type HandoffFlags} from './handoff.ts';
 /** `direct` chooses how the page is reached (own port instead of the managed front); it is not part of the instance identity. */
-export interface OpenInputs {input:string;compare?:string;reference?:string;animation?:string;control?:boolean;direct?:boolean;config?:string;parts?:string;source?:string;full?:string;head?:string}
+export interface OpenInputs {input:string;compare?:string;reference?:string;animation?:string;control?:boolean;direct?:boolean;config?:string;parts?:string;source?:string;full?:string;head?:string;keypoints?:string}
 /** The producer handoff flags (#101) among the inputs, or undefined when none was given. */
 export function handoffFlags(inputs:OpenInputs):HandoffFlags|undefined{const present=HANDOFF_FLAGS.filter(f=>inputs[f]!==undefined);if(!present.length)return undefined;return Object.fromEntries(present.map(f=>[f,inputs[f]])) as unknown as HandoffFlags;}
 export type OpenPackage=({mode:'single';p:ReviewPackage;inputs:OpenInputs;contentHash:string}|{mode:'compare';p:ComparePackage;inputs:OpenInputs;contentHash:string})&{selection:AnimationSelection|null};

package/src/readings-run.ts

@@ -10,6 +10,7 @@ import { copyFile, lstat, mkdir, readFile, rm, writeFile } from 'node:fs/promise
 import { dirname, isAbsolute, join, relative } from 'node:path';
 import { safeFile, type ReviewPackage } from './manifest.ts';
 import { resolveCompiler, runTool, type InstalledTool } from './producer.ts';
+import { scheduleText, type EnvironmentSchedule } from './environment-schedule.ts';
 import { environmentSchedule, helpHasEnvironment, parseReadingsRequest, READING_FILE, readingLabel, readingResult, READINGS_SCHEMA, READINGS_SINCE, ReadingsError, renderArgs, type ReadingBuild, type ReadingRequest, type ReadingResult, type ReadingsRequest } from './readings.ts';
 
 const sha256 = (bytes: string | Uint8Array) => createHash('sha256').update(bytes).digest('hex');
@@ -39,7 +40,7 @@ export async function runReading(r: ReadingRequest, animation: string, candidate
   try { const stored = JSON.parse(await readFile(resultFile, 'utf8')) as { key: string; result: ReadingResult }; if (stored.key === key) return stored.result; } catch { /* not run yet */ }
   await rm(dir, { recursive: true, force: true });
   await mkdir(dir, { recursive: true, mode: 0o700 });
-  if (schedule) await writeFile(join(dir, 'environment.json'), JSON.stringify(schedule, null, 1) + '\n', { mode: 0o600 });
+  if (schedule) await writeFile(join(dir, 'environment.json'), scheduleText(schedule as EnvironmentSchedule), { mode: 0o600 });
   const run = await runTool(compiler.bin, renderArgs(r, animation, { candidate, out: 'render', environment: schedule ? 'environment.json' : null }), { cwd: dir });
   let json: unknown = null, fps: number | null = null;
   if (run.exitCode === 0) {

package/src/readings.ts

@@ -7,6 +7,7 @@
  * Review judges nothing here: a reading is not a gate, and an unknown slot or bone is rigc's to refuse.
  */
 import { firstRefusal } from './producer.ts';
+import { parseSchedule, ScheduleError, standingSchedule, type EnvironmentSchedule } from './environment-schedule.ts';
 
 export const READINGS_SCHEMA = 'rig-review-readings/1';
 /** The first `rig-c` release with all five readings (its CHANGELOG: 2.63.0, "render: --overlaps names which slot covers which"). */
@@ -24,7 +25,8 @@ export type ReadingKind = ReadingRequest['kind'];
 export const READING_KINDS: readonly ReadingKind[] = ['folds', 'pass-through', 'seam', 'overlaps', 'angle-range'];
 /** The world the physics answers while the readings are posed: the Environment block's wind and gravity as they stand (x right, y down). */
 export interface ReadingEnvironment { wind: [number, number]; gravity: [number, number] }
-export interface ReadingsRequest { animation: string; readings: ReadingRequest[]; environment: ReadingEnvironment | null }
+/** #112: with "Use for readings" on, the Environment block's exported `rigc-environment/1` schedule goes in its place. */
+export interface ReadingsRequest { animation: string; readings: ReadingRequest[]; environment: ReadingEnvironment | EnvironmentSchedule | null }
 
 export class ReadingsError extends Error { constructor(readonly code: string, detail: string) { super(`${code}: ${detail}`); } }
 const bad = (detail: string): never => { throw new ReadingsError('READINGS_REQUEST_INVALID', detail); };
@@ -57,8 +59,12 @@ export function parseReadingsRequest(input: unknown): ReadingsRequest {
   const readings = (v.readings as unknown[]).map((r, i) => parseReading(r, `readings[${i}]`));
   const labels = readings.map(readingLabel);
   if (new Set(labels).size !== labels.length) bad('readings: one entry named twice');
-  let environment: ReadingEnvironment | null = null;
-  if (v.environment !== null) { const e = record(v.environment, 'environment'); exactly(e, ['wind', 'gravity'], 'environment'); environment = { wind: pair(e.wind, 'environment.wind'), gravity: pair(e.gravity, 'environment.gravity') }; }
+  let environment: ReadingsRequest['environment'] = null;
+  if (v.environment !== null) {
+    const e = record(v.environment, 'environment');
+    if (Object.hasOwn(e, 'spec')) { try { environment = parseSchedule(e); } catch (error) { if (error instanceof ScheduleError) bad(`environment: ${error.message}`); throw error; } }
+    else { exactly(e, ['wind', 'gravity'], 'environment'); environment = { wind: pair(e.wind, 'environment.wind'), gravity: pair(e.gravity, 'environment.gravity') }; }
+  }
   return { animation, readings, environment };
 }
 
@@ -88,8 +94,8 @@ export interface RenderPaths { candidate: string; out: string; environment: stri
 export function renderArgs(r: ReadingRequest, animation: string, paths: RenderPaths): string[] {
   return ['render', '--candidate', paths.candidate, '--animation', animation, ...(paths.environment ? ['--environment', paths.environment] : []), ...readingFlag(r), '--out', paths.out];
 }
-/** The schedule file `--environment` reads: the world as it stands, from t = 0. */
-export const environmentSchedule = (e: ReadingEnvironment) => ({ spec: 'rigc-environment/1', steps: [{ t: 0, wind: e.wind, gravity: e.gravity }] });
+/** The schedule file `--environment` reads: the world as it stands, from t = 0 — or, #112, the exported schedule as sent. */
+export const environmentSchedule = (e: ReadingEnvironment | EnvironmentSchedule): EnvironmentSchedule => ('spec' in e ? e : standingSchedule(e));
 /** Whether this rigc's `render --help` lists `--environment` (the schedule is passed only then). */
 export const helpHasEnvironment = (lines: readonly string[]) => lines.some(l => /^\s*--environment\s/.test(l));
 
@@ -216,7 +222,7 @@ export function ticksOnClip(ticks: readonly ReadingTick[], jobAnimation: string,
 
 /** `context.readings`: the pairs chosen and where they ran (the builds' identities), never the results' bytes. */
 export interface ReadingsContext {
-  schema: typeof READINGS_SCHEMA; animation: string; requests: ReadingRequest[]; environment: ReadingEnvironment | null; environmentPassed: boolean;
+  schema: typeof READINGS_SCHEMA; animation: string; requests: ReadingRequest[]; environment: ReadingsRequest['environment']; environmentPassed: boolean;
   builds: { inspected: string; scratch: string | null }; compiler: { package: string; version: string };
   ticks: { inspected: number; scratch: number | null };
 }