onejs-sl 0.2.1 → 0.4.0

package/src/lang/builtins.ts

@@ -45,13 +45,12 @@ const name = (op: number): string => {
 const val = (v: Num): Val => (typeof v === "number" ? (sl.float(v) as unknown as Val) : v)
 
 /**
- * Asserts an operand's width where the two backends would otherwise part ways.
+ * Asserts an operand's width where the backends would otherwise part ways.
  *
- * The VM keeps every value in a float4 register and writes `a.xy` or `a.rgb`
- * whatever it was handed, so a noise call on a float3 quietly works there. The
- * generated HLSL passes the real type to `sl_valueNoise(float2)` and either
- * truncates with a warning or fails to compile. Neither outcome is one an
- * author should discover after ejecting, so the narrow ops say so here.
+ * The generated HLSL passes the real type to `sl_valueNoise(float2)` and either
+ * truncates with a warning or fails to compile, while a browser may accept it.
+ * Neither outcome is one an author should discover in a build, so the narrow
+ * ops say so here.
  */
 function widthMustBe(fn: string, v: Num, want: 1 | 2 | 3 | 4, why: string): Val {
     const got = typeof v === "number" ? 1 : v.width
@@ -126,12 +125,10 @@ value(SLOP.LUMINANCE, 1, 1, (a) => sl.luminance(colourOperand("luminance", a[0]!
 value(SLOP.NOISE, 1, 1, (a) => sl.noise(point("noise", a[0]!) as never))
 value(SLOP.SIMPLEX, 1, 1, (a) => sl.simplex(point("simplex", a[0]!) as never))
 value(SLOP.VORONOI, 1, 1, (a) => sl.voronoi(point("voronoi", a[0]!) as never))
-// The octave count is an immediate, so it has to be a number at parse time.
-// `lower.ts` folds constants before it gets here and rejects anything else with
-// a message that says why, rather than letting this cast be the error.
-value(SLOP.FBM, 1, 2, (a) => sl.fbm(point("fbm", a[0]!) as never, octaves("fbm", a[1])))
-value(SLOP.TURBULENCE, 1, 2, (a) => sl.turbulence(point("turbulence", a[0]!) as never, octaves("turbulence", a[1])))
-value(SLOP.RIDGED, 1, 2, (a) => sl.ridged(point("ridged", a[0]!) as never, octaves("ridged", a[1])))
+// The octave count is 3 when left out, and may be a value (`sl.fbm` says how).
+value(SLOP.FBM, 1, 2, (a) => sl.fbm(point("fbm", a[0]!) as never, a[1] ?? 3))
+value(SLOP.TURBULENCE, 1, 2, (a) => sl.turbulence(point("turbulence", a[0]!) as never, a[1] ?? 3))
+value(SLOP.RIDGED, 1, 2, (a) => sl.ridged(point("ridged", a[0]!) as never, a[1] ?? 3))
 
 /** Every field is sampled at a float2. */
 function point(fn: string, v: Num): Val {
@@ -139,20 +136,10 @@ function point(fn: string, v: Num): Val {
 }
 
 special(SLOP.SAMPLE, 2, 2)
+special(SLOP.SAMPLE_LOD, 3, 3)
 special(SLOP.SDF, 1, 7)
 special(SLOP.RAMP, 3, 64)
 
-function octaves(fn: string, v: Num | undefined): number {
-    if (v === undefined) return 3
-    if (typeof v !== "number") {
-        throw new SLError(
-            `${fn}'s octave count is baked into the instruction, so it has to be a constant. ` +
-            `A uniform or a computed value cannot change how many octaves the shader runs.`,
-        )
-    }
-    return v
-}
-
 export const BUILTINS: Readonly<Record<string, Builtin>> = table
 
 /**

package/src/lang/check.ts

@@ -49,11 +49,15 @@ const DERIVED_NAMES = new Set(Object.keys(DERIVED_INPUTS))
  * The GLSL spellings whose HLSL name means the same wherever it is written, so
  * the hint can be a one click fix (`Specs/SL_NEXT.md` 5, Decision 1 A). The
  * rest of `SL_GLSL_HINT` gets the hint alone: `mod` floors where `%` truncates,
- * `ivec2` truncates where `float2` does not, `atan` is `atan2` only with two
- * arguments (handled at the call), and `textureLod` names a builtin that is not
- * implemented yet.
+ * `ivec2` truncates where `float2` does not, and `atan` is `atan2` only with two
+ * arguments (handled at the call).
  */
-const GLSL_RENAMES = new Set(["mix", "fract", "texture", "vec2", "vec3", "vec4", "gl_FragCoord", "iTime", "iResolution"])
+const GLSL_RENAMES = new Set([
+    "mix", "fract", "texture", "textureLod", "vec2", "vec3", "vec4", "gl_FragCoord", "iTime", "iResolution",
+])
+
+/** The builtins whose first argument is a texture, which is not a value anywhere else. */
+const SAMPLES = new Set(["tex2D", "tex2Dlod"])
 
 const rename = (from: string, to: string): SLFix => ({ title: `Replace ${from} with ${to}`, replacement: to })
 
@@ -427,7 +431,7 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
                 if (textures.has(e.name)) {
                     fail(
                         `"${e.name}" is a texture, and a texture is only ever the first argument of ` +
-                        `tex2D. Write \`tex2D(${e.name}, uv)\``,
+                        `tex2D or tex2Dlod. Write \`tex2D(${e.name}, uv)\``,
                         e.pos, e.name.length,
                     )
                 }
@@ -458,9 +462,9 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
                 // Only reached while collecting: the call was refused, and its
                 // arguments are separate questions, so a mistake inside one is
                 // not hidden by the call's own. `fract(uv * wrap)` is two
-                // mistakes. tex2D's first argument is the texture, which is a
-                // value only there.
-                const tex = e.callee.k === "ident" && e.callee.name === "tex2D"
+                // mistakes. A sample's first argument is the texture, which is
+                // not a value.
+                const tex = e.callee.k === "ident" && SAMPLES.has(e.callee.name)
                 for (const a of tex ? e.args.slice(1) : e.args) attempt(() => checkExpr(fn, a, scope))
                 return
             }
@@ -529,13 +533,22 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
 
         const builtin = BUILTINS[n]
         if (builtin !== undefined) {
-            if (n === "tex2D") {
+            if (SAMPLES.has(n)) {
                 const [tex, ...rest] = e.args
+                // HLSL's own tex2Dlod packs the level into a float4 with the uv.
+                if (n === "tex2Dlod" && e.args.length === 2) {
+                    fail(
+                        "tex2Dlod takes the uv and the mip level separately, `tex2Dlod(t, uv, lod)`, " +
+                        "rather than HLSL's float4(uv, 0, lod)",
+                        e.pos,
+                    )
+                }
                 arity(e, n, builtin.min, builtin.max)
                 if (tex === undefined || tex.k !== "ident" || !textures.has(tex.name)) {
+                    const lod = n === "tex2Dlod" ? ", 0" : ""
                     fail(
-                        `tex2D samples a texture declared in this file, as in \`texture2D grain;\` ` +
-                        `then \`tex2D(grain, uv)\``,
+                        `${n} samples a texture declared in this file, as in \`texture2D grain;\` ` +
+                        `then \`${n}(grain, uv${lod})\``,
                         (tex ?? e).pos,
                     )
                 }

package/src/lang/glsl.ts

@@ -75,7 +75,7 @@ const GLSL_TYPES = new Set(["float", "int", "uint", "bool", "vec2", "vec3", "vec
 /** A straight rename, the meaning unchanged. */
 const RENAME: Record<string, string> = {
     vec2: "float2", vec3: "float3", vec4: "float4", mix: "lerp", fract: "frac",
-    texture: "tex2D", texture2D: "tex2D", iTime: "time", iGlobalTime: "time", gl_FragCoord: "fragCoord",
+    texture: "tex2D", texture2D: "tex2D", textureLod: "tex2Dlod", iTime: "time", iGlobalTime: "time", gl_FragCoord: "fragCoord",
 }
 
 /** A rename that changes what the value can hold, so it is said. */
@@ -101,7 +101,6 @@ const MISSING: Record<string, string> = {
     iChannelTime: "a texture has no time of its own",
     iChannelResolution: "a texture's size cannot be read yet",
     iSampleRate: "there is no audio",
-    textureLod: "tex2Dlod is not implemented yet; tex2D samples with the texture's own filtering",
     texelFetch: "a texture cannot be read without filtering yet",
     textureSize: "a texture's size cannot be read yet",
     dFdx: "there are no derivatives", dFdy: "there are no derivatives", fwidth: "there are no derivatives",

package/src/lang/index.ts

@@ -8,7 +8,7 @@
  *     import { parse } from "onejs-sl"
  *
  *     const plasma = parse(source, { file: "plasma.sl" })
- *     //    ^ a Program: encode() it, emit HLSL from it, hash it
+ *     //    ^ a Program: compile() it, emit HLSL from it, hash it
  *
  * The parser is not a second authoring surface with its own semantics. It
  * lowers through the EDSL, so a `.sl` file and the `sl.program(...)` an author

package/src/lang/lower.ts

@@ -15,8 +15,7 @@
  * existed. Reassignment is free; it is not a store.
  *
  * **`for` unrolls.** The bounds are constants, so the body is lowered once per
- * iteration with the counter substituted as a number. `sl.unrolled` records the
- * span so the instruction ceiling error can name the loop that spent it.
+ * iteration with the counter substituted as a number.
  *
  * **`if` becomes `select`.** Both sides are lowered and every local assigned in
  * either is selected at the join. A constant condition folds instead, which is
@@ -33,7 +32,9 @@
  * than an optimisation.
  */
 
-import { controlProblem, DERIVED_INPUTS, INPUTS, type Program, type SLType, type UniformControl } from "../ir"
+import {
+    controlProblem, DERIVED_INPUTS, INPUTS, RAMP_STOP_COMPUTED, writtenColour, type Program, type SLType, type UniformControl,
+} from "../ir"
 import type { SlSdfKind } from "../shapes"
 import * as sl from "../sl"
 import type { Num, Val } from "../sl"
@@ -421,20 +422,19 @@ export function lower(checked: Checked, errors?: SLParseError[]): Program {
                         count++
                         if (count > MAX_UNROLL) {
                             fail(
-                                `this loop would unroll to more than ${MAX_UNROLL} iterations. There is ` +
-                                `no loop on either backend, so every iteration is emitted in full and ` +
-                                `the VM runs at most 256 instructions`,
+                                `this loop would unroll to more than ${MAX_UNROLL} iterations. A for ` +
+                                `loop unrolls at build time, so every iteration is written out in full`,
                                 s.pos,
                             )
                         }
                     }
-                    at(s.pos, () => sl.unrolled(count, () => {
+                    at(s.pos, () => {
                         for (let i = from; s.inclusive ? i <= to : i < to; i += step) {
                             const inner = new Scope(scope)
                             inner.declare(s.counter, { width: 1, value: i })
                             exec(s.body, inner, ret)
                         }
-                    }))
+                    })
                     break
                 }
                 default:
@@ -447,7 +447,7 @@ export function lower(checked: Checked, errors?: SLParseError[]): Program {
         if (typeof v !== "number") {
             fail(
                 `a for loop unrolls at build time, so its ${what} has to be a constant. This one is ` +
-                `computed while the shader runs, and neither backend has a loop to run it in`,
+                `computed while the shader runs`,
                 e.pos,
             )
         }
@@ -604,19 +604,7 @@ export function lower(checked: Checked, errors?: SLParseError[]): Program {
             if (typeof p === "number" || p.width !== 2) {
                 fail(`sdf.${shape} measures the distance to a point, so it takes a float2`, e.args[0]!.pos)
             }
-            const params: number[] = []
-            for (const a of e.args.slice(1)) {
-                const v = lowerExpr(a, scope)
-                if (typeof v !== "number") {
-                    fail(
-                        `sdf.${shape}'s shape parameters ride inside the instruction, so they have to ` +
-                        `be constants. A size that changes belongs on the point: scale or offset it ` +
-                        `before the call`,
-                        a.pos,
-                    )
-                }
-                params.push(v)
-            }
+            const params = e.args.slice(1).map((a) => lowerExpr(a, scope))
             return at(e.pos, () => sl.sdf(shape, p as never, params))
         }
 
@@ -626,29 +614,35 @@ export function lower(checked: Checked, errors?: SLParseError[]): Program {
             return construct(n as TypeName, e.args.map((a) => lowerExpr(a, scope)), e.pos)
         }
 
-        if (n === "tex2D") {
+        if (n === "tex2D" || n === "tex2Dlod") {
             const texName = (e.args[0] as Extract<Expr, { k: "ident" }>).name
             const tex = samplers.get(texName)!
             const uv = lowerExpr(e.args[1]!, scope)
             if (typeof uv === "number" || uv.width !== 2) {
-                fail("tex2D samples at a float2", e.args[1]!.pos)
+                fail(`${n} samples at a float2`, e.args[1]!.pos)
             }
-            return at(e.pos, () => tex.sample(uv as never) as unknown as Val)
+            if (n === "tex2D") return at(e.pos, () => tex.sample(uv as never) as unknown as Val)
+            const lod = lowerExpr(e.args[2]!, scope)
+            if (typeof lod !== "number" && lod.width !== 1) {
+                fail(`a mip level is one number, and this is a ${widthType(lod.width)}`, e.args[2]!.pos)
+            }
+            return at(e.pos, () => tex.sampleLevel(uv as never, lod) as unknown as Val)
         }
 
         if (n === "ramp") {
             const t = lowerExpr(e.args[0]!, scope)
-            const stops: string[] = []
-            for (const a of e.args.slice(1)) {
-                if (a.k !== "hex") {
-                    fail(
-                        "a ramp's stops are constants, written as colours: `ramp(t, #000018, #0080ff, " +
-                        "#ffffff)`. A stop that changes wants lerp between two uniforms instead",
-                        a.pos,
-                    )
+            // A hex stays the string it was, so a ramp of hexes is the program
+            // it always was. Anything else is a value, which has to be a colour
+            // as written (`sl.ramp` says why), a colour uniform say.
+            const stops = e.args.slice(1).map((a) => {
+                if (a.k === "hex") return a.hex
+                const v = lowerExpr(a, scope)
+                if (typeof v === "number" || v.width < 3) {
+                    fail(`a ramp's stop is a colour, a float3 or a float4, and this is a ${typeof v === "number" ? "float" : widthType(v.width)}`, a.pos)
                 }
-                stops.push(a.hex)
-            }
+                if (writtenColour(v.owner.nodes, v.ref) === null) fail(RAMP_STOP_COMPUTED, a.pos)
+                return v as never
+            })
             return at(e.pos, () => sl.ramp(t, stops) as unknown as Val)
         }
 
@@ -730,8 +724,8 @@ const ARITH: Record<ArithOp, (a: number, b: number) => number> = {
     "-": (a, b) => a - b,
     "*": (a, b) => a * b,
     "/": (a, b) => a / b,
-    // JavaScript's % is the truncated remainder, which is what HLSL's fmod is
-    // and what the VM's OP_MOD implements. Folding it in JS is the same answer.
+    // JavaScript's % is the truncated remainder, which is what HLSL's fmod is.
+    // Folding it in JS is the same answer.
     "%": (a, b) => a % b,
 }
 

package/src/lang/parser.ts

@@ -344,8 +344,8 @@ class Parser {
         if (t.text === "for") return this.parseFor()
         if (t.text === "while" || t.text === "do") {
             this.fail(
-                `there is no ${t.text} loop: the VM has no branches, so a loop has to unroll, and ` +
-                `only a for loop with constant bounds can. See a for loop`,
+                `there is no ${t.text} loop: a loop unrolls at build time, and only a for loop ` +
+                `with constant bounds can. See a for loop`,
                 t,
             )
         }

package/src/lang/prelude.ts

@@ -7,8 +7,8 @@
  *
  * ADDING TO IT COSTS A FUNCTION AND A TEST, NOT AN OPCODE IN THREE PLACES. That
  * is the whole argument for having a text language with inlining functions: a
- * library entry is source, so it lands in the VM, in generated HLSL and in the
- * hash by being ordinary code, and neither backend learns anything new.
+ * library entry is source, so it lands in every emitter's output and in the
+ * hash by being ordinary code, and no backend learns anything new.
  *
  * WHY THE SOURCE IS A STRING AND NOT A FILE. `onejs-sl` ships raw TypeScript
  * and runs inside a browser worker on play.onejs.com, where

package/src/ops.ts

@@ -1,10 +1,9 @@
 /**
  * The shader language opcode table.
  *
- * Phase 1 of `Specs/SHADER_LANG.md`. This is the contract three things will
- * share: the encoder that packs a program into a texture, the VM shader that
- * evaluates it, and the HLSL emitter that prints it. Two of those do not exist
- * yet, which is exactly why the numbering is fixed now rather than later.
+ * Phase 1 of `Specs/SHADER_LANG.md`. The numbers are in every program's hash
+ * and in its JSON, so an opcode keeps its number for good, and one that goes
+ * leaves its number unused.
  *
  * Numbered in families with gaps, the convention `fx/ops.ts` set, so a reader
  * can tell what an opcode is from its value:
@@ -22,18 +21,6 @@
  * a dense table.
  */
 
-/**
- * The newest VM encoding this encoder writes. The VM accepts 1..its own and
- * refuses newer, where there is a VM: a WebGL player draws compiled and never
- * reads the buffer.
- *
- * A payload records the LOWEST version that can run it (`Encoded.wire`), not
- * this: a program that uses nothing new stays 1, so a new bundle still runs on
- * an older Play container, and only a program that needs a newer instruction
- * is refused by an older one rather than drawn wrong.
- */
-export const SL_WIRE_VERSION = 2
-
 /**
  * How many uniforms and textures one program may declare: the language's caps,
  * for a host to read.
@@ -50,11 +37,7 @@ export const SL_WIRE_VERSION = 2
 export const UNIFORM_SLOTS = 16
 export const TEXTURE_SLOTS = 4
 
-/** The VM's names for the same two caps, which go when the VM does. */
-export const VM_UNIFORMS = UNIFORM_SLOTS
-export const VM_TEXTURES = TEXTURE_SLOTS
-
-/** Input ids, fixed here because the shader switches on them. */
+/** Input ids, which the web emitter switches on. */
 export const INPUT_ID: Record<string, number> = {
     uv: 0, fragCoord: 1, resolution: 2, time: 3, aspect: 4,
 }
@@ -136,10 +119,7 @@ export const SLOP = {
     // made bright. imm.x carries the octave count, as FBM does.
     TURBULENCE: 133,
     RIDGED: 134,
-    // VM only: an SDF given a fifth or sixth parameter, which one instruction's
-    // four immediates and id cannot hold. The encoder makes it (`forVm`); the
-    // IR and every compiled backend only ever see SDF.
-    SDF_WIDE: 135,
+    // 135 was SDF_WIDE, the VM's form of an SDF with more than four parameters.
 
     // Sampling
     SAMPLE: 144,
@@ -149,7 +129,7 @@ export const SLOP = {
 export type SLOpCode = (typeof SLOP)[keyof typeof SLOP]
 
 /**
- * How many arguments each op takes, for validation and for the encoder.
+ * How many arguments each op takes, for validation.
  *
  * -1 means variadic: COMPOSE takes however many parts add up to its width, RAMP
  * takes a value plus its stops. Everything else is fixed, and a mismatch is a
@@ -176,8 +156,10 @@ export const SL_ARITY: Record<number, number> = {
 
     [SLOP.RAMP]: -1, [SLOP.HSV2RGB]: 1, [SLOP.RGB2HSV]: 1, [SLOP.LUMINANCE]: 1, [SLOP.TO_LINEAR]: 1,
 
-    [SLOP.NOISE]: 1, [SLOP.SIMPLEX]: 1, [SLOP.FBM]: 1, [SLOP.SDF]: 1,
-    [SLOP.VORONOI]: 1, [SLOP.TURBULENCE]: 1, [SLOP.RIDGED]: 1, [SLOP.SDF_WIDE]: 2,
+    // An SDF takes the point, or the point and its parameters as operands; an
+    // octave op the point, or the point and its count (`formProblem` in ir.ts).
+    [SLOP.NOISE]: 1, [SLOP.SIMPLEX]: 1, [SLOP.FBM]: -1, [SLOP.SDF]: -1,
+    [SLOP.VORONOI]: 1, [SLOP.TURBULENCE]: -1, [SLOP.RIDGED]: -1,
 
     [SLOP.SAMPLE]: 1, [SLOP.SAMPLE_LOD]: 2,
 }
@@ -187,18 +169,10 @@ export const SL_NAME: Record<number, string> = Object.fromEntries(
     Object.entries(SLOP).map(([name, code]) => [code, name.toLowerCase()]),
 )
 
-export const FIRST_ARITHMETIC = 16
-export const FIRST_MATHS = 48
-export const FIRST_GEOMETRY = 80
-export const FIRST_INTERPOLATE = 96
-export const FIRST_COLOUR = 112
-export const FIRST_PROCEDURAL = 128
-export const FIRST_SAMPLING = 144
+const FIRST_SAMPLING = 144
 
 /**
- * Ops that read a texture. Sampler slots are the one resource ceiling neither
- * backend can widen (16 in a fragment shader on WebGL2), so these are counted
- * at record time.
+ * Ops that read a texture.
  */
 export function isSampling(op: number): boolean {
     return op >= FIRST_SAMPLING
@@ -292,7 +266,6 @@ export const SL_HLSL: Record<number, SLSurface> = {
     [SLOP.VORONOI]: { call: "voronoi" },
     [SLOP.TURBULENCE]: { call: "turbulence" },
     [SLOP.RIDGED]: { call: "ridged" },
-    [SLOP.SDF_WIDE]: { syntax: "sdf.<shape>(p, ...) given a fifth or sixth parameter" },
 
     [SLOP.SAMPLE]: { call: "tex2D" },
     [SLOP.SAMPLE_LOD]: { call: "tex2Dlod" },
@@ -303,16 +276,14 @@ export const SL_HLSL: Record<number, SLSurface> = {
  *
  * Numbered so the families stay in order, and refused at the surface until
  * somebody writes both halves. A program reaching one would render as whatever
- * the VM's dispatch falls through to and fail outright in the HLSL emitter,
- * which is the silent-disagreement failure this design exists to prevent, so
- * the parser names them rather than treating them as unknown identifiers.
+ * nothing: the emitters have no case for them. So the parser names them rather
+ * than treating them as unknown identifiers.
  *
  * `REMAP` is here because the opcode is unimplemented; the SURFACE `remap` is a
  * macro over arithmetic and works everywhere.
  */
 export const SL_UNIMPLEMENTED: Record<number, string> = {
-    [SLOP.RGB2HSV]: "neither the VM shader nor the HLSL emitter has a case for it",
-    [SLOP.SAMPLE_LOD]: "the VM samples without an explicit LOD; use tex2D",
+    [SLOP.RGB2HSV]: "no backend has a case for it yet",
     [SLOP.REMAP]: "the surface form is a macro over arithmetic, so the opcode is unused",
 }
 

package/src/params.ts

@@ -54,6 +54,7 @@ const INTRINSIC: Record<string, readonly string[]> = {
     distance: ["x", "y"], dot: ["x", "y"], cross: ["x", "y"], reflect: ["i", "n"],
     lerp: ["x", "y", "s"], step: ["y", "x"], smoothstep: ["min", "max", "x"],
     tex2D: ["s", "t"],
+    tex2Dlod: ["s", "t", "lod"],
 }
 
 /**
@@ -161,6 +162,7 @@ export const BUILTIN_DOCS: Readonly<Record<string, string>> = {
     turbulence: "Simplex creases layered in octaves, 1 to 4: fire, smoke, marble.",
     ridged: "Turbulence made bright at its creases: ridges, lightning, cracks.",
     tex2D: "The colour of texture s at the uv t, with straight alpha.",
+    tex2Dlod: "The colour of texture s at the uv t from mip level lod: 0 is the full size, 1 half, and so on.",
     sdf: "The signed distance from p to a shape, negative inside: `sdf.circle(p, r)`.",
     ramp: "t mapped through evenly spaced colour stops, from the first at 0 to the last at 1.",
 }

package/src/serial.ts

@@ -9,14 +9,16 @@
  * older one is migrated to this one and rehashed under it.
  */
 import {
-    INPUTS, SLError, SL_IR_VERSION, TYPE, checkCaps, controlOf, controlProblem, hashProgram,
-    type NodeRef, type Program, type SLNode, type SLType, type TextureDecl, type UniformDecl,
+    INPUTS, SLError, SL_HASH_VERSION, SL_IR_VERSION, TYPE, checkCaps, controlOf, controlProblem, formProblem, hashProgram,
+    programVersion, type NodeRef, type Program, type SLNode, type SLType, type TextureDecl, type UniformDecl,
 } from "./ir"
-import { SL_ARITY, SL_NAME } from "./ops"
+import { SLOP, SL_ARITY, SL_NAME } from "./ops"
 
 export interface ProgramJSON {
     /** `SL_IR_VERSION` of the writer. Absent means 1. */
     v: number
+    /** `SL_HASH_VERSION` of the writer, which `hash` was computed under. Absent means 1. */
+    h?: number
     nodes: SLNode[]
     result: NodeRef
     uniforms: UniformDecl[]
@@ -25,7 +27,10 @@ export interface ProgramJSON {
 }
 
 export function toJSON(p: Program): ProgramJSON {
-    return { v: p.version, nodes: p.nodes, result: p.result, uniforms: p.uniforms, textures: p.textures, hash: p.hash }
+    return {
+        v: p.version, h: SL_HASH_VERSION, nodes: p.nodes, result: p.result, uniforms: p.uniforms, textures: p.textures,
+        hash: p.hash,
+    }
 }
 
 export function fromJSON(json: unknown): Program {
@@ -38,24 +43,71 @@ export function fromJSON(json: unknown): Program {
             `Update onejs-sl to read it, or rebuild it from its .sl source.`)
     }
     if (!Array.isArray(j.nodes) || j.nodes.length === 0) fail("it has no nodes")
-    const nodes = j.nodes.map((n, i) => node(n, i))
-    const result = j.result
-    if (!Number.isInteger(result) || result! < 0 || result! >= nodes.length) fail(`its result ${String(result)} is not a node`)
-    if (nodes[result!]!.type !== TYPE.VEC4) fail("its result is not a float4")
+    const written = j.nodes.map((n, i) => node(n, i))
+    if (!Number.isInteger(j.result) || j.result! < 0 || j.result! >= written.length) {
+        fail(`its result ${String(j.result)} is not a node`)
+    }
+    // The lowest version that has these nodes, which is what the writer
+    // recorded unless the file predates version 2 (whose nodes version 2 reads
+    // as they are) or was edited. One that claims less than its nodes need
+    // holds something its version never had.
+    const needs = programVersion(written)
+    if (v < needs && v >= 2) fail(`it says IR version ${v} and holds nodes version ${needs} added; it was changed after it was written`)
+    const { nodes, result } = v < 3 ? toOperands(written, j.result!) : { nodes: written, result: j.result! }
+    nodes.forEach((n, i) => {
+        const problem = n.k === "call" ? formProblem(n, nodes) : null
+        if (problem !== null) fail(`node ${i} is not a form its op has: ${problem}`)
+    })
+    if (nodes[result]!.type !== TYPE.VEC4) fail("its result is not a float4")
     const uniforms = (j.uniforms ?? []).map(uniform)
     const textures = (j.textures ?? []).map(texture)
     checkCaps({ uniforms, textures })
     for (const n of nodes) {
         if (n.k === "uniform" && n.slot >= uniforms.length) fail(`a node reads uniform slot ${n.slot}, which is not declared`)
     }
-    const hash = hashProgram(nodes, result!, uniforms, textures)
-    // Same version, so the same maths and the same hash; a different one means
-    // the file was edited or damaged, and its cached shader belongs to
-    // something else. An older version is rehashed under this one on purpose.
-    if (v === SL_IR_VERSION && j.hash !== undefined && j.hash !== hash) {
+    const version = programVersion(nodes)
+    const hash = hashProgram(nodes, result, uniforms, textures)
+    // The same IR version and hash scheme, so the same hash; a different one
+    // means the file was edited or damaged, and its cached shader belongs to
+    // something else. A file an older version or scheme wrote is rehashed under
+    // this one on purpose.
+    if (v === version && (j.h ?? 1) === SL_HASH_VERSION && j.hash !== undefined && j.hash !== hash) {
         fail(`its hash ${j.hash} does not match its nodes (${hash}); it was changed after it was written`)
     }
-    return { version: SL_IR_VERSION, nodes, result: result!, uniforms, textures, hash, loops: [] }
+    return { version, nodes, result, uniforms, textures, hash }
+}
+
+/**
+ * A graph written before IR 3, with the forms it had then moved to the one each
+ * op has now: an sdf's shape parameters after its id and an octave op's count
+ * were immediates, and are operands. Each constant goes in just before the
+ * call that reads it, and every later reference moves along.
+ */
+function toOperands(written: readonly SLNode[], writtenResult: NodeRef): { nodes: SLNode[]; result: NodeRef } {
+    const nodes: SLNode[] = []
+    const at: NodeRef[] = []
+    const constant = (type: SLType, v: number[]): NodeRef => nodes.push({ k: "const", type, v }) - 1
+    written.forEach((n, i) => {
+        const imm = n.k === "call" ? n.imm ?? [] : []
+        if (n.k === "call" && n.op === SLOP.SDF && n.args.length === 1) {
+            if (imm.length < 5) fail(`node ${i} is an sdf with ${imm.length} immediates; one written before IR 3 has at least 5`)
+            const q = constant(TYPE.VEC4, [imm[1]!, imm[2]!, imm[3]!, imm[4]!])
+            const r = constant(TYPE.VEC2, [imm[5] ?? 0, imm[6] ?? 0])
+            at[i] = nodes.push({ ...n, args: [at[n.args[0]!]!, q, r], imm: [imm[0]!] }) - 1
+            return
+        }
+        const octaves = n.k === "call" && (n.op === SLOP.FBM || n.op === SLOP.TURBULENCE || n.op === SLOP.RIDGED)
+        if (octaves && n.args.length === 1) {
+            if (imm.length < 1) fail(`node ${i} is ${SL_NAME[n.op]} with no octave count`)
+            const count = constant(TYPE.FLOAT, [imm[0]!])
+            at[i] = nodes.push({ ...n, args: [at[n.args[0]!]!, count], imm: imm.slice(1) }) - 1
+            return
+        }
+        const moved: SLNode = n.k === "call" ? { ...n, args: n.args.map((a) => at[a]!) }
+            : n.k === "swizzle" ? { ...n, src: at[n.src]! } : n
+        at[i] = nodes.push(moved) - 1
+    })
+    return { nodes, result: at[writtenResult]! }
 }
 
 function node(n: unknown, i: number): SLNode {