@githolon/dsl 0.2.0 → 0.2.2

package/src/usd_state.ts

@@ -0,0 +1,505 @@
+// NOMOS — Nomos Sovereign: participants act · verify · remember LOCALLY; hosted
+// remotes are replaceable custody/transport, not truth.  ⇒ ONE Nomos GitHolon
+// wasm32-wasip1 artifact {kernel · projection · embedded
+// QuickJS engine} on V8 + WASI-shim, byte-identical everywhere.  V8 = portability; the one
+// wasm = determinism.  No native, no wasmtime, no 2nd artifact, no domain-JS on bare V8.
+// If a file isn't this / hosting this / authoring for this / proving this — it's gone.
+
+/**
+ * USD STATE EMISSION — projection folds as TIME SAMPLES (spike 2: scrub the ledger).
+ *
+ * THE THESIS: everything a githolon computes is a DETERMINISTIC FOLD over an ordered
+ * intent chain, so the projection emits as a USD STATE layer whose timeCode axis IS
+ * the chain: frame t = the read model after folding intents 0..t. Scrubbing the
+ * timeline in usdview is replaying the chain; state-at-t is a frame; and because the
+ * fold is deterministic, the SAME chain emits the SAME bytes — visualization is a
+ * pure function of the ledger.
+ *
+ * TIMECODE LAW: `t` is the CHAIN INDEX (0-based position of the sealed intent on
+ * `main`), NEVER wall clock. Wall-clock time rides INSIDE intents (caller-stamped
+ * ISO strings / captured HLCs) and may appear as attribute VALUES; it never becomes
+ * the time axis. The axis is causal order — the only order the kernel certifies.
+ *
+ * LAYERING (the spike-1 composition, extended): the law layers of
+ * `usd_layers.ts` lower WHAT MAY HAPPEN (`/Nomos/<domain>` — aggregates, merge
+ * drivers, directives); this module lowers WHAT HAS HAPPENED (`/NomosState/<domain>`
+ * — one prim per aggregate INSTANCE, folded fields as sampled attributes). The
+ * scrub stage stacks the state layer OVER the law layers — disjoint scopes today
+ * (state never re-touches law paths), but the stack order states the relationship:
+ * state is the stronger, later word, and a future state layer that DID carry
+ * opinions about law paths would compose by exactly these rules.
+ *
+ * TWO TIERS, one emitter:
+ *   * AUTO-LAYOUT (abstract domains): instances are placed on a deterministic grid
+ *     in first-appearance order, jittered by an FNV-1a hash of the aggregate id —
+ *     SEEDED BY THE ID, so the same chain lays out the same picture everywhere.
+ *     Geometry is synthetic (a gprim exists so usdview shows something).
+ *   * SPATIAL (domains with positional fields): `xformOp:translate` is sampled FROM
+ *     THE FOLDED FIELDS — the geometry is the domain's own truth, genuinely 3D, and
+ *     a moved asset MOVES as you scrub.
+ *
+ * Everything is emitted SAMPLE-ON-CHANGE (USD holds the previous sample, exactly the
+ * fold's semantics: state persists until a later intent changes it) and in sorted
+ * order (types, ids, fields) so the bytes are canonical.
+ *
+ * BUILD-TIME ONLY (sibling of `usd_layers.ts`): reached via `@githolon/dsl/usd-state`,
+ * never the runtime barrel. The deployable package bytes and the domainHash do not
+ * move — state emission reads the PROJECTION, it never enters the law.
+ */
+import { primName, usdaString, usdaStringArray } from "./usd_layers.js";
+
+/** The state-layer format marker (customLayerData `nomos:format`). */
+export const NOMOS_USD_STATE_LAYER_FORMAT = "nomos.usd-state-layer.v1";
+/** The scrub-stage root format marker — state stacked over the law layers. */
+export const NOMOS_USD_SCRUB_STAGE_FORMAT = "nomos.usd-scrub-stage.v1";
+
+// ── input shapes (REAL projection reads — never hand-simulated state) ────────────────
+
+/**
+ * One projection row as the read engine returns it (`query_by_id` / `query`):
+ * `type` + `id` + the partially folded `data`. The recorder reads these BETWEEN
+ * intents from the engine's projection — the emitter only ever renders real folds.
+ */
+export interface StateRow {
+  readonly type: string;
+  readonly id: string;
+  readonly data: Readonly<Record<string, unknown>>;
+}
+
+/** The projection after folding chain prefix 0..t (t = the intent's chain index). */
+export interface StateFrame {
+  /** The CHAIN INDEX of the intent whose fold this frame shows — the timeCode. */
+  readonly t: number;
+  /** The sealed intent's id (provenance label, rides the Chain prim). */
+  readonly intentId: string;
+  /** `domain/directiveId` — what happened at this frame (the scrub legend). */
+  readonly directive: string;
+  /** Every tracked aggregate instance's rows AFTER this fold. */
+  readonly rows: readonly StateRow[];
+}
+
+/** Field kinds from the read manifest (`aggregateFieldKinds`) — drives attr typing. */
+export type StateFieldKinds = Readonly<
+  Record<string, Readonly<Record<string, { readonly kind: string }>>>
+>;
+
+/** Positions from folded fields (the spatial tier). Field values must fold numeric. */
+export interface SpatialMapping {
+  readonly x: string;
+  readonly y: string;
+  readonly z?: string;
+  /** Uniform scale applied to the folded values (e.g. decimetres → metres). */
+  readonly scale?: number;
+}
+
+export interface StateLayerOptions {
+  readonly domain: string;
+  readonly frames: readonly StateFrame[];
+  /** Read-manifest field kinds: `set` fields emit `string[]`, `int` fields emit `int`. */
+  readonly fieldKinds?: StateFieldKinds;
+  /** Present ⇒ spatial tier (translate sampled from folds); absent ⇒ seeded auto-layout. */
+  readonly spatial?: SpatialMapping;
+}
+
+// ── deterministic layout (seeded by the aggregate id hash — never Math.random) ───────
+
+/** FNV-1a 32-bit over UTF-16 code units — the layout seed for one aggregate id. */
+export function fnv1a32(s: string): number {
+  let h = 0x811c9dc5;
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 0x01000193) >>> 0;
+  }
+  return h >>> 0;
+}
+
+/**
+ * The AUTO-LAYOUT position for instance `rank` of `n` (first-appearance order,
+ * id-tiebroken): a square grid with 3-unit spacing, centred on the origin, plus a
+ * sub-cell jitter derived from the id hash so distinct instances read as distinct
+ * even when ranks collide visually. Pure: (id, rank, n) → position, no ambient state.
+ */
+export function seededLayout(id: string, rank: number, n: number): [number, number, number] {
+  const cols = Math.max(1, Math.ceil(Math.sqrt(n)));
+  const col = rank % cols;
+  const row = Math.floor(rank / cols);
+  const h = fnv1a32(id);
+  const jx = ((h & 0xffff) / 0xffff - 0.5) * 1.5;
+  const jy = (((h >>> 16) & 0xffff) / 0xffff - 0.5) * 1.5;
+  const half = (cols - 1) / 2;
+  return [(col - half) * 3 + jx, (row - half) * 3 + jy, 0];
+}
+
+/** Deterministic display colour from the id hash (HSV slice → RGB, fully pure). */
+export function seededColor(id: string): [number, number, number] {
+  const h6 = (fnv1a32(id) % 360) / 60;
+  const c = 0.55,
+    m = 0.35;
+  const x = c * (1 - Math.abs((h6 % 2) - 1));
+  const [r, g, b] =
+    h6 < 1 ? [c, x, 0] : h6 < 2 ? [x, c, 0] : h6 < 3 ? [0, c, x] : h6 < 4 ? [0, x, c] : h6 < 5 ? [x, 0, c] : [c, 0, x];
+  const f = (v: number) => Math.round((v + m) * 1000) / 1000;
+  return [f(r), f(g), f(b)];
+}
+
+// ── canonical value rendering ─────────────────────────────────────────────────────────
+
+/** JSON with sorted object keys at every depth — one byte form per value. */
+function canonicalJson(v: unknown): string {
+  if (Array.isArray(v)) return `[${v.map(canonicalJson).join(",")}]`;
+  if (v !== null && typeof v === "object") {
+    const o = v as Record<string, unknown>;
+    return `{${Object.keys(o)
+      .sort()
+      .map((k) => `${JSON.stringify(k)}:${canonicalJson(o[k])}`)
+      .join(",")}}`;
+  }
+  return JSON.stringify(v);
+}
+
+/** A finite double as usda text (JS canonical shortest repr — deterministic). */
+function num(n: number): string {
+  if (!Number.isFinite(n)) throw new Error(`usd-state: non-finite number ${n} cannot enter a usda literal`);
+  return String(n);
+}
+
+const fail = (msg: string): never => {
+  throw new Error(`usd-state: ${msg}`);
+};
+
+/** The instance-track key: NUL-joined so no (type, id) pair can collide. */
+const keyOf = (type: string, id: string): string => `${type}\u0000${id}`;
+
+// ── the emitter ───────────────────────────────────────────────────────────────────────
+
+interface InstanceTrack {
+  readonly type: string;
+  readonly id: string;
+  firstSeen: number;
+  /** field → declared usda type + ordered (t, renderedValue) samples, on change only. */
+  readonly fields: Map<string, { decl: string; samples: { t: number; value: string }[] }>;
+  /** spatial tier: ordered (t, xyz) samples, recorded on change only. */
+  readonly positions: { t: number; xyz: [number, number, number] }[];
+}
+
+/** usda literal + declared type for one folded field value. */
+function renderField(kind: string | undefined, value: unknown): { decl: string; literal: string } {
+  if (kind === "set") {
+    if (!Array.isArray(value) || value.some((x) => typeof x !== "string")) {
+      return { decl: "string", literal: usdaString(canonicalJson(value)) };
+    }
+    return { decl: "string[]", literal: usdaStringArray([...(value as string[])].sort()) };
+  }
+  if (kind === "int" && typeof value === "number" && Number.isInteger(value)) {
+    return { decl: "int", literal: String(value) };
+  }
+  if ((kind === "string" || kind === "enum") && typeof value === "string") {
+    return { decl: "string", literal: usdaString(value) };
+  }
+  // maps / json / refs / derived strings / anything else: canonical JSON in a string.
+  return {
+    decl: "string",
+    literal: usdaString(typeof value === "string" ? value : canonicalJson(value)),
+  };
+}
+
+function spatialValue(row: StateRow, field: string, t: number, scale: number): number {
+  const v = row.data[field];
+  if (typeof v !== "number" || !Number.isFinite(v)) {
+    fail(
+      `spatial tier requires a finite numeric '${field}' on ${row.type}:${row.id} at chain index ${t}; ` +
+        `folded value was ${canonicalJson(v)} — fix the fixture chain (the directive must set '${field}') ` +
+        `or drop the spatial mapping (the seeded auto-layout tier needs no fields)`,
+    );
+  }
+  return (v as number) * scale;
+}
+
+/**
+ * THE STATE LAYER: one `#usda` text whose timeCode axis is the chain. Per aggregate
+ * instance: an `Xform` prim (under `/NomosState/<domain>/<Type>/`) holding
+ *   * `visibility` timeSamples — `invisible` before the instance's first fold,
+ *     `inherited` from its birth frame (instances APPEAR as you scrub);
+ *   * `xformOp:translate` — auto-layout (static, id-hash-seeded) or spatial
+ *     timeSamples (from the folded positional fields, sample-on-change);
+ *   * one `custom` attribute per folded field, `nomos:state:<field>`, timeSamples
+ *     recorded ON CHANGE (USD's held interpolation = the fold's persistence);
+ *   * a child gprim so stock tooling renders something (synthetic for the abstract
+ *     tier — stated honestly; the SPATIAL tier's transform is the domain's truth).
+ * Plus `/NomosState/<domain>/Chain` carrying `nomos:chain:directive` / `:intent`
+ * timeSamples — the scrub legend (what happened at frame t).
+ *
+ * Fail-closed: frames must be CONTIGUOUS chain indices from 0 (the timeCode IS the
+ * chain position); spatial fields must fold finite numbers. Pure function — same
+ * frames, same bytes.
+ */
+export function emitStateLayerUsda(opts: StateLayerOptions): string {
+  const { domain, frames } = opts;
+  if (frames.length === 0) {
+    fail(`no frames for domain '${domain}' — record one frame per sealed intent (chain index 0 onward)`);
+  }
+  frames.forEach((f, i) => {
+    if (f.t !== i) {
+      fail(
+        `frame ${i} carries t=${f.t} — the timeCode IS the chain index, never wall clock; ` +
+          `record exactly one frame per sealed intent, contiguous from 0`,
+      );
+    }
+  });
+  const scale = opts.spatial?.scale ?? 1;
+
+  // ── fold the frames into per-instance sample tracks ──
+  const tracks = new Map<string, InstanceTrack>(); // keyed by keyOf(type, id)
+  const order: string[] = []; // first-appearance order (the layout rank)
+  for (const frame of frames) {
+    const seen = new Set<string>();
+    for (const row of frame.rows) {
+      const key = keyOf(row.type, row.id);
+      if (seen.has(key)) fail(`frame t=${frame.t} carries duplicate rows for ${row.type}:${row.id}`);
+      seen.add(key);
+      let track = tracks.get(key);
+      if (track === undefined) {
+        track = { type: row.type, id: row.id, firstSeen: frame.t, fields: new Map(), positions: [] };
+        tracks.set(key, track);
+        order.push(key);
+      }
+      const kinds = opts.fieldKinds?.[row.type];
+      for (const field of Object.keys(row.data).sort()) {
+        const { decl, literal } = renderField(kinds?.[field]?.kind, row.data[field]);
+        let entry = track.fields.get(field);
+        if (entry === undefined) {
+          entry = { decl, samples: [] };
+          // A field that first folds AFTER the instance's birth gets a VALUE BLOCK
+          // (`None`) at the birth frame — USD evaluates a timeSamples attribute as
+          // its first sample held BACKWARD, which would show the value before the
+          // fold produced it. The block keeps every earlier frame honestly unfolded.
+          if (frame.t > track.firstSeen) entry.samples.push({ t: track.firstSeen, value: "None" });
+          track.fields.set(field, entry);
+        } else if (entry.decl !== decl) {
+          fail(
+            `field '${field}' of ${row.type}:${row.id} changed shape mid-chain ` +
+              `(${entry.decl} → ${decl} at t=${frame.t}) — a folded field keeps one wire kind; ` +
+              `check the read manifest's aggregateFieldKinds for '${row.type}'`,
+          );
+        }
+        const last = entry.samples[entry.samples.length - 1];
+        if (last === undefined || last.value !== literal) {
+          entry.samples.push({ t: frame.t, value: literal });
+        }
+      }
+      if (opts.spatial !== undefined) {
+        const xyz: [number, number, number] = [
+          spatialValue(row, opts.spatial.x, frame.t, scale),
+          spatialValue(row, opts.spatial.y, frame.t, scale),
+          opts.spatial.z !== undefined ? spatialValue(row, opts.spatial.z, frame.t, scale) : 0,
+        ];
+        const last = track.positions[track.positions.length - 1];
+        if (last === undefined || last.xyz.join(",") !== xyz.join(",")) {
+          track.positions.push({ t: frame.t, xyz });
+        }
+      }
+    }
+  }
+  const rankOf = new Map(order.map((k, i) => [k, i]));
+
+  // ── render ──
+  const lines: string[] = [
+    `#usda 1.0`,
+    `(`,
+    `    doc = """Nomos STATE layer — the projection as time samples. timeCode t = the`,
+    `chain index of the sealed intent whose fold frame t shows (causal order, never`,
+    `wall clock). Scrubbing the timeline IS replaying the chain; the same chain emits`,
+    `the same bytes. Composes OVER the domain's law layers (see the scrub stage)."""`,
+    `    customLayerData = {`,
+    `        string "nomos:format" = ${usdaString(NOMOS_USD_STATE_LAYER_FORMAT)}`,
+    `        string "nomos:domain" = ${usdaString(domain)}`,
+    `        string "nomos:timeCode" = "chain index (intent position on main)"`,
+    `    }`,
+    `    defaultPrim = "NomosState"`,
+    `    startTimeCode = 0`,
+    `    endTimeCode = ${frames.length - 1}`,
+    `    timeCodesPerSecond = 1`,
+    `    framesPerSecond = 1`,
+    `    metersPerUnit = 1`,
+    `    upAxis = "Z"`,
+    `)`,
+    ``,
+    `def Scope "NomosState"`,
+    `{`,
+    `    def Scope ${usdaString(primName(domain))}`,
+    `    {`,
+  ];
+  const ind2 = "        ";
+  const ind3 = "            ";
+  const ind4 = "                ";
+
+  // THE SCRUB CAMERA — a fixed, deterministic top-down orthographic plan view over
+  // the union extent of every placement (spatial samples or seeded layout), so
+  // usdrecord/usdview frames are COMPARABLE across timeCodes (auto-framing per frame
+  // would re-zoom and hide the motion). Pure function of the same inputs as the rest.
+  {
+    const pts: [number, number, number][] = [];
+    for (const track of tracks.values()) {
+      if (opts.spatial !== undefined) pts.push(...track.positions.map((p) => p.xyz));
+      else pts.push(seededLayout(track.id, rankOf.get(keyOf(track.type, track.id))!, order.length));
+    }
+    if (pts.length > 0) {
+      const min = [0, 1, 2].map((i) => Math.min(...pts.map((p) => p[i]!)));
+      const max = [0, 1, 2].map((i) => Math.max(...pts.map((p) => p[i]!)));
+      const extent = Math.max(max[0]! - min[0]!, max[1]! - min[1]!) + 4;
+      const cx = (min[0]! + max[0]!) / 2;
+      const cy = (min[1]! + max[1]!) / 2;
+      const h = max[2]! + extent;
+      lines.push(
+        `${ind2}def Camera "ScrubCam"`,
+        `${ind2}{`,
+        `${ind3}token projection = "orthographic"`,
+        `${ind3}float horizontalAperture = ${num(extent * 10)}`,
+        `${ind3}float verticalAperture = ${num(extent * 10)}`,
+        `${ind3}float2 clippingRange = (0.1, ${num(h + extent + 10)})`,
+        `${ind3}double3 xformOp:translate = (${num(cx)}, ${num(cy)}, ${num(h)})`,
+        `${ind3}uniform token[] xformOpOrder = ["xformOp:translate"]`,
+        `${ind2}}`,
+        ``,
+      );
+    }
+  }
+
+  // The chain legend prim: what happened at each frame.
+  lines.push(
+    `${ind2}def Scope "Chain"`,
+    `${ind2}{`,
+    `${ind3}custom string nomos:chain:directive.timeSamples = {`,
+    ...frames.map((f) => `${ind4}${f.t}: ${usdaString(f.directive)},`),
+    `${ind3}}`,
+    `${ind3}custom string nomos:chain:intent.timeSamples = {`,
+    ...frames.map((f) => `${ind4}${f.t}: ${usdaString(f.intentId)},`),
+    `${ind3}}`,
+    `${ind2}}`,
+    ``,
+  );
+
+  // Instances grouped per aggregate type, both levels sorted.
+  const byType = new Map<string, InstanceTrack[]>();
+  for (const track of tracks.values()) {
+    const list = byType.get(track.type) ?? [];
+    if (list.length === 0) byType.set(track.type, list);
+    list.push(track);
+  }
+  for (const type of [...byType.keys()].sort()) {
+    lines.push(`${ind2}def Scope ${usdaString(primName(type))}`, `${ind2}{`);
+    const instances = byType.get(type)!.sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+    for (const inst of instances) {
+      const key = keyOf(inst.type, inst.id);
+      lines.push(`${ind3}def Xform ${usdaString(primName(inst.id))}`, `${ind3}{`);
+      // Birth: invisible before the first fold, inherited from it.
+      if (inst.firstSeen > 0) {
+        lines.push(
+          `${ind4}token visibility.timeSamples = {`,
+          `${ind4}    0: "invisible",`,
+          `${ind4}    ${inst.firstSeen}: "inherited",`,
+          `${ind4}}`,
+        );
+      }
+      // Placement: spatial samples from the folds, or the seeded static layout.
+      if (opts.spatial !== undefined) {
+        lines.push(
+          `${ind4}double3 xformOp:translate.timeSamples = {`,
+          ...inst.positions.map((p) => `${ind4}    ${p.t}: (${p.xyz.map(num).join(", ")}),`),
+          `${ind4}}`,
+        );
+      } else {
+        const [x, y, zz] = seededLayout(inst.id, rankOf.get(key)!, order.length);
+        lines.push(`${ind4}double3 xformOp:translate = (${num(x)}, ${num(y)}, ${num(zz)})`);
+      }
+      lines.push(
+        `${ind4}uniform token[] xformOpOrder = ["xformOp:translate"]`,
+        `${ind4}custom string nomos:type = ${usdaString(inst.type)}`,
+        `${ind4}custom string nomos:id = ${usdaString(inst.id)}`,
+      );
+      // Folded fields, sample-on-change (held interpolation = the fold's persistence).
+      for (const field of [...inst.fields.keys()].sort()) {
+        const { decl, samples } = inst.fields.get(field)!;
+        lines.push(
+          `${ind4}custom ${decl} nomos:state:${field}.timeSamples = {`,
+          ...samples.map((s) => `${ind4}    ${s.t}: ${s.value},`),
+          `${ind4}}`,
+        );
+      }
+      // The gprim (synthetic for the abstract tier — usdview needs SOMETHING to draw;
+      // the spatial tier's TRANSFORM is the domain's truth, the gprim is still a marker).
+      const [r, g, b] = seededColor(inst.id);
+      if (opts.spatial !== undefined) {
+        lines.push(
+          `${ind4}def Cube "geo"`,
+          `${ind4}{`,
+          `${ind4}    double size = 1`,
+          `${ind4}    color3f[] primvars:displayColor = [(${num(r)}, ${num(g)}, ${num(b)})]`,
+          `${ind4}}`,
+        );
+      } else {
+        lines.push(
+          `${ind4}def Sphere "geo"`,
+          `${ind4}{`,
+          `${ind4}    double radius = 0.6`,
+          `${ind4}    color3f[] primvars:displayColor = [(${num(r)}, ${num(g)}, ${num(b)})]`,
+          `${ind4}}`,
+        );
+      }
+      lines.push(`${ind3}}`, ``);
+    }
+    if (lines[lines.length - 1] === "") lines.pop();
+    lines.push(`${ind2}}`, ``);
+  }
+  if (lines[lines.length - 1] === "") lines.pop();
+  lines.push(`    }`, `}`, ``);
+  return lines.join("\n");
+}
+
+/**
+ * THE SCRUB STAGE root: state stacked OVER the law layers. `subLayers` is
+ * STRONGEST-FIRST (USD layer-stack order) — the state layer leads, then the law
+ * layers in Nomos module order REVERSED (the spike-1 correspondence: the module
+ * list composes weak→strong, the sublayer list reads strong→weak). Open this one
+ * file in usdview/usdcat and the WHOLE picture composes: what may happen
+ * (`/Nomos/<domain>`) and what has happened (`/NomosState/<domain>`), on one
+ * scrubbable timeline.
+ */
+export function stateScrubStageUsda(opts: {
+  readonly domain: string;
+  readonly stateLayerRelPath: string;
+  readonly lawLayerRelPathsWeakToStrong: readonly string[];
+  readonly endTimeCode: number;
+}): string {
+  if (opts.lawLayerRelPathsWeakToStrong.length === 0) {
+    fail(
+      `scrub stage for '${opts.domain}' has no law layers — emit them first ` +
+        `(nomos-compile --layered, spike 1) so state has law to compose over`,
+    );
+  }
+  const strongestFirst = [opts.stateLayerRelPath, ...[...opts.lawLayerRelPathsWeakToStrong].reverse()];
+  return [
+    `#usda 1.0`,
+    `(`,
+    `    doc = """Nomos SCRUB STAGE — the state layer (what has happened: the projection`,
+    `as time samples, timeCode = chain index) composed OVER the law layers (what may`,
+    `happen: aggregates, merge drivers, directives — spike 1). subLayers are`,
+    `STRONGEST-FIRST; scrubbing the timeline replays the chain."""`,
+    `    customLayerData = {`,
+    `        string "nomos:format" = ${usdaString(NOMOS_USD_SCRUB_STAGE_FORMAT)}`,
+    `        string "nomos:domain" = ${usdaString(opts.domain)}`,
+    `    }`,
+    `    defaultPrim = "NomosState"`,
+    `    startTimeCode = 0`,
+    `    endTimeCode = ${opts.endTimeCode}`,
+    `    timeCodesPerSecond = 1`,
+    `    framesPerSecond = 1`,
+    `    metersPerUnit = 1`,
+    `    upAxis = "Z"`,
+    `    subLayers = [`,
+    ...strongestFirst.map((p, i) => `        @${p}@${i < strongestFirst.length - 1 ? "," : ""}`),
+    `    ]`,
+    `)`,
+    ``,
+  ].join("\n");
+}