diff --git a/design/astral-projection/three/README.md b/design/astral-projection/three/README.md
new file mode 100644
index 000000000..f93aa0213
--- /dev/null
+++ b/design/astral-projection/three/README.md
@@ -0,0 +1,43 @@
+# Astral exercise motion studies
+
+Standalone review page; no app integration. Reuses the promo-film installation of
+**Three.js 0.169.0**, with no CDN or additional dependencies. From the Breeze root:
+
+```sh
+node design/promo-film/three/tools/serve.mjs
+```
+
+Open http://127.0.0.1:8772/design/astral-projection/three/index.html . Choose an exercise,
+play/pause, scrub or click a cue marker. 10×/60× speeds help review long sessions.
+Deep links accept `?exercise=bruce_rope_exit&t=1450`.
+
+`src/sessions.json` is an English snapshot of the practices catalogue, all six
+session timelines and exact cue captions. Refresh with
+`python3 design/astral-projection/three/tools/sync-data.py`. The private test
+compares the snapshot against the current upstream files before rendering.
+Caption text remains present through the silence until the next cue.
+
+Each exercise owns a separate scene, sampled directly from session seconds.
+Foundation shows thumb stirring and leg strokes; Current shows limb bounces and
+circuits; Elevator shows the shaft rising around a descending observer; Spin
+shows an exterior awareness point (not an exit); Rope shows reaching/climbing;
+Roll-Out shows left/right whole-body turns. Physical muscles stay still.
+Return/recall cues stop the technique. These are guided-imagery illustrations.
+
+The shared `design/promo-film/three/src/character-shaders.js` provides warm wrapped
+lighting, a cool Fresnel rim and lightweight subsurface approximation; astral
+figures use one interpolated noise octave, alpha and HDR bloom. Painted Lumi and
+both Tai Chi teachers use the same palette and alpha-gradient relief shading,
+preserving their source artwork and premultiplied edges. No new normal textures.
+The preview caps render width at 960px and pixel ratio at 1; low-poly body meshes
+share geometry/materials. Real phone GPU performance still needs device review.
+
+Local test (owns a private Xvfb and headless Chromium; never the desktop):
+
+```sh
+build-queue -- node design/astral-projection/three/tools/verify.mjs
+```
+
+Frames and the report go to `build/astral-threejs/`. The test compares every cue
+boundary, tests controls and captures several cue times in all six exercises,
+plus portrait framing and promo character shader compilation. No audio plays.
diff --git a/design/astral-projection/three/index.html b/design/astral-projection/three/index.html
new file mode 100644
index 000000000..2b547d486
--- /dev/null
+++ b/design/astral-projection/three/index.html
@@ -0,0 +1,16 @@
+
+
+
+
+
Six guided visual studies · review before app integration
+
● Physical body● Awareness / astral double
+
+
+
+
+
diff --git a/design/astral-projection/three/src/main.js b/design/astral-projection/three/src/main.js
new file mode 100644
index 000000000..299cd649a
--- /dev/null
+++ b/design/astral-projection/three/src/main.js
@@ -0,0 +1,135 @@
+import * as T from 'three'
+import { EffectComposer } from 'three/addons/postprocessing/EffectComposer.js'
+import { RenderPass } from 'three/addons/postprocessing/RenderPass.js'
+import { UnrealBloomPass } from 'three/addons/postprocessing/UnrealBloomPass.js'
+import { OutputPass } from 'three/addons/postprocessing/OutputPass.js'
+import { createExercise } from './scenes.js'
+
+const items = await fetch('./src/sessions.json').then(response => response.json())
+const canvas = document.querySelector('canvas')
+const renderer = new T.WebGLRenderer({ canvas, antialias: false, preserveDrawingBuffer: true })
+renderer.setPixelRatio(1)
+const composer = new EffectComposer(renderer)
+const renderPass = new RenderPass(new T.Scene(), new T.Camera())
+composer.addPass(renderPass)
+composer.addPass(new UnrealBloomPass(new T.Vector2(640, 360), 0.48, 0.45, 0.95))
+composer.addPass(new OutputPass())
+const scenes = items.map(createExercise)
+const picker = document.querySelector('#exercise')
+const seek = document.querySelector('#seek')
+const play = document.querySelector('#play')
+let selected = 0
+let time = 0
+let playing = false
+let last = performance.now()
+let state
+const clock = seconds => `${Math.floor(seconds / 60)}:${String(Math.floor(seconds % 60)).padStart(2, '0')}`
+items.forEach((item, index) => picker.add(new Option(item.title, index)))
+
+function draw() {
+ const view = scenes[selected]
+ state = view.update(time)
+ renderPass.scene = view.scene
+ renderPass.camera = view.camera
+ composer.render()
+ seek.value = time
+ document.querySelector('#clock').textContent = `${clock(time)} / ${clock(items[selected].duration)}`
+ document.querySelector('#phase').textContent = time === items[selected].duration ? 'Complete · recall and write' : state.phase
+ document.querySelector('#cue-number').textContent = `CUE ${state.index + 1} / ${items[selected].cues.length} · ${clock(state.cue.second)}`
+ document.querySelector('#caption').textContent = state.cue.text
+ document.querySelectorAll('#markers button').forEach((button, index) => button.setAttribute('aria-current', String(index === state.index)))
+}
+
+function setPlaying(value) {
+ playing = value
+ play.textContent = playing ? 'Pause' : 'Play'
+ last = performance.now()
+}
+
+function choose(index) {
+ selected = index
+ picker.value = index
+ time = 0
+ seek.max = items[index].duration
+ setPlaying(false)
+ const markers = document.querySelector('#markers')
+ markers.replaceChildren(...items[index].cues.map((cue, i) => {
+ const button = document.createElement('button')
+ button.textContent = clock(cue.second)
+ button.title = cue.text
+ button.setAttribute('aria-label', `Cue ${i + 1}: ${clock(cue.second)}`)
+ button.onclick = () => {
+ time = cue.second
+ draw()
+ }
+ return button
+ }))
+ draw()
+}
+
+function resize() {
+ // One capped-resolution render, shared materials and low-poly figures.
+ const width = Math.min(960, canvas.clientWidth)
+ const height = Math.round(width * canvas.clientHeight / canvas.clientWidth)
+ renderer.setSize(width, height, false)
+ composer.setSize(width, height)
+ scenes.forEach(view => {
+ view.camera.aspect = width / height
+ view.camera.updateProjectionMatrix()
+ })
+ draw()
+}
+picker.onchange = () => choose(Number(picker.value))
+play.onclick = () => {
+ if (time >= items[selected].duration) time = 0
+ setPlaying(!playing)
+}
+document.querySelector('#restart').onclick = () => {
+ time = 0
+ setPlaying(false)
+ draw()
+}
+seek.oninput = () => {
+ time = Number(seek.value)
+ draw()
+}
+window.addEventListener('resize', resize)
+choose(0)
+resize()
+const params = new URLSearchParams(location.search)
+const initial = items.findIndex(item => item.id === params.get('exercise'))
+if (initial >= 0) choose(initial)
+if (params.has('t')) {
+ time = Math.max(0, Math.min(items[selected].duration, Number(params.get('t')) || 0))
+ draw()
+}
+
+// Deterministic review API used by the private-display tests.
+window.astral = {
+ items,
+ select: choose,
+ seek(value) {
+ time = Math.max(0, Math.min(items[selected].duration, value))
+ draw()
+ return this.state()
+ },
+ state() { return { id: items[selected].id, time, playing, cue: state.cue.key, caption: state.cue.text, index: state.index, phase: state.phase } },
+ pixels() {
+ const gl = renderer.getContext()
+ const bytes = new Uint8Array(canvas.width * canvas.height * 4)
+ gl.readPixels(0, 0, canvas.width, canvas.height, gl.RGBA, gl.UNSIGNED_BYTE, bytes)
+ let bright = 0
+ for (let i = 0; i < bytes.length; i += 4) if (Math.max(bytes[i], bytes[i + 1], bytes[i + 2]) > 80) bright += 1
+ return { bright, total: canvas.width * canvas.height, calls: renderer.info.render.calls }
+ },
+}
+function frame(now) {
+ if (playing) {
+ time = Math.min(items[selected].duration, time + Math.min(1, (now - last) / 1000) * Number(document.querySelector('#speed').value))
+ if (time >= items[selected].duration) setPlaying(false)
+ draw()
+ }
+ last = now
+ requestAnimationFrame(frame)
+}
+requestAnimationFrame(frame)
diff --git a/design/astral-projection/three/src/scenes.js b/design/astral-projection/three/src/scenes.js
new file mode 100644
index 000000000..38d62b7e0
--- /dev/null
+++ b/design/astral-projection/three/src/scenes.js
@@ -0,0 +1,209 @@
+import * as T from 'three'
+import { bodyMaterial } from '../../../promo-film/three/src/character-shaders.js'
+import { sample } from './timeline.js'
+
+const smooth = x => T.MathUtils.smoothstep(x, 0, 1)
+const pulse = t => (Math.sin(t * 2.4) + 1) / 2
+
+function figure(material) {
+ const root = new T.Group()
+ const sphere = new T.SphereGeometry(1, 16, 12)
+ const part = (position, scale) => {
+ const mesh = new T.Mesh(sphere, material)
+ mesh.position.set(...position)
+ mesh.scale.set(...scale)
+ root.add(mesh)
+ return mesh
+ }
+ part([0, 0.55, 0], [0.29, 0.47, 0.17])
+ part([0, 1.18, 0], [0.20, 0.24, 0.19])
+ part([0, 0.04, 0], [0.27, 0.23, 0.17])
+ // Nose and closed eyes give the otherwise simple body an unmistakable face.
+ part([0, 1.17, 0.19], [0.045, 0.055, 0.06])
+ for (const x of [-0.075, 0.075]) {
+ const eye = new T.Mesh(sphere, new T.MeshBasicMaterial({ color: '#493f43' }))
+ eye.position.set(x, 1.23, 0.177)
+ eye.scale.set(0.045, 0.012, 0.016)
+ root.add(eye)
+ }
+ const arms = []
+ for (const side of [-1, 1]) {
+ part([side * 0.14, -0.53, 0], [0.12, 0.52, 0.12])
+ part([side * 0.14, -1.03, 0.07], [0.12, 0.10, 0.21])
+ const arm = new T.Group()
+ arm.position.set(side * 0.35, 0.84, 0)
+ const limb = new T.Mesh(sphere, material)
+ limb.position.y = -0.36
+ limb.scale.set(0.09, 0.42, 0.09)
+ arm.add(limb)
+ root.add(arm)
+ arms.push(arm)
+ }
+ root.rotation.x = -Math.PI / 2
+ root.position.y = 0.4
+ return { root, arms }
+}
+
+// Every exercise gets its own scene and deterministic time sampler. No
+// accumulated transforms: a scrub produces the same pose as uninterrupted play.
+export function createExercise(item) {
+ const scene = new T.Scene()
+ scene.background = new T.Color('#0b1424')
+ scene.fog = new T.Fog('#0b1424', 10, 25)
+ const camera = new T.PerspectiveCamera(42, 2, 0.1, 40)
+ camera.position.set(4.3, 5.4, 6.3)
+ camera.lookAt(0, 0.6, 0)
+ const physicalMaterial = bodyMaterial()
+ const energyMaterial = bodyMaterial({ astral: true })
+ const physical = figure(physicalMaterial)
+ const energy = figure(energyMaterial)
+ scene.add(physical.root, energy.root)
+ const bed = new T.Mesh(new T.BoxGeometry(1.6, 0.16, 3.3), new T.MeshBasicMaterial({ color: '#243349' }))
+ bed.position.y = 0.1
+ scene.add(bed)
+ const grid = new T.GridHelper(18, 24, '#29455c', '#15283c')
+ grid.position.y = -0.1
+ scene.add(grid)
+ const haloMaterial = new T.MeshBasicMaterial({ color: '#84efff', toneMapped: false })
+ const point = new T.Mesh(new T.SphereGeometry(0.065, 12, 8), haloMaterial)
+ scene.add(point)
+ const ring = new T.Mesh(new T.TorusGeometry(0.14, 0.014, 6, 32), haloMaterial)
+ ring.rotation.x = -Math.PI / 2
+ scene.add(ring)
+ const shaft = new T.Group()
+ for (let i = 0; i < 9; i += 1) {
+ const floor = new T.Mesh(new T.BoxGeometry(3.5, 0.025, 3.5), new T.MeshBasicMaterial({ color: '#29445a', wireframe: true, transparent: true, opacity: 0.35 }))
+ shaft.add(floor)
+ }
+ scene.add(shaft)
+ const rope = new T.Mesh(new T.CylinderGeometry(0.025, 0.025, 4, 8), new T.MeshBasicMaterial({ color: '#dac9a3' }))
+ rope.position.set(0, 2.5, -0.3)
+ scene.add(rope)
+ const cordGeometry = new T.BufferGeometry().setFromPoints(Array.from({ length: 25 }, () => new T.Vector3()))
+ const cord = new T.Line(cordGeometry, new T.LineBasicMaterial({ color: '#c4f4ff', toneMapped: false }))
+ scene.add(cord)
+ const current = new T.Group()
+ for (let i = 0; i < 14; i += 1) {
+ const bead = new T.Mesh(new T.SphereGeometry(0.025, 6, 4), haloMaterial)
+ current.add(bead)
+ }
+ scene.add(current)
+
+ function update(seconds) {
+ const state = sample(item, seconds)
+ const { time: t, index: i, progress: u } = state
+ const id = item.id
+ energyMaterial.uniforms.time.value = t
+ physicalMaterial.uniforms.time.value = t
+ energy.root.position.set(0, 0.43, 0)
+ energy.root.rotation.set(-Math.PI / 2, 0, 0)
+ energy.arms.forEach(arm => arm.rotation.set(0, 0, 0))
+ const isReturn = i >= item.cues.length - (id.includes('current') || id.includes('elevator') ? 2 : 1)
+ const fade = isReturn ? 1 - smooth(u) : 1
+ energy.root.visible = !id.includes('spin') && !id.includes('elevator') && fade > 0.001
+ point.visible = false
+ ring.visible = false
+ rope.visible = id.includes('rope') && i >= 11 && i < 19
+ shaft.visible = id.includes('elevator') && i >= 6 && i < 13
+ current.visible = false
+ if (shaft.visible) {
+ // The shaft rises around the resting observer: felt downward travel.
+ const descend = i <= 8 || i === 11
+ const offset = descend ? (t % 24) / 24 : 0.5
+ shaft.children.forEach((floor, n) => { floor.position.y = (n - 4 + offset) * 0.7 })
+ }
+ if (id.includes('foundation') && i >= 1 && i < 9) {
+ point.visible = true
+ ring.visible = true
+ if (i < 4) {
+ point.position.set(0.39 + 0.055 * Math.cos(t * 8), 0.56, -0.12 + 0.055 * Math.sin(t * 8))
+ } else if (i === 4) {
+ point.position.set(0.38, 0.55, -0.22 + pulse(t) * 0.45)
+ } else {
+ point.position.set(i === 5 ? -0.14 : 0.14, 0.54, 1.05 - (t % 3) / 3 * 1.05)
+ }
+ ring.position.copy(point.position)
+ if (i >= 7) {
+ current.visible = true
+ current.children.forEach((bead, n) => bead.position.set(n % 2 ? -0.14 : 0.14, 0.52, 1.05 - ((t / 3 + n / 14) % 1) * 1.05))
+ }
+ }
+ const circuit = id.includes('current') && i >= 1 && i < 11 || id.includes('rope') && (i === 7 || i === 8) || id.includes('roll') && i === 4
+ if (circuit) {
+ current.visible = true
+ current.children.forEach((bead, n) => {
+ const cycle = (t / (i < 4 ? 1.5 : 6) + n / 14) % 1
+ const side = n % 2 ? -1 : 1
+ let z = 1.05 - cycle * 2.35
+ let x = side * 0.14
+ if (id.includes('current') && i <= 2) {
+ z = 1.05 - pulse(t + n * 0.12)
+ x = i === 1 ? 0.14 : side * 0.14
+ } else if (id.includes('current') && (i === 3 || i === 5)) {
+ x = side * 0.38
+ z = 0.15 - pulse(t + n * 0.12)
+ } else if (id.includes('current') && i === 4) {
+ z = 1.05 - cycle * 1.05
+ } else if (cycle > 0.5) {
+ z = -1.3 + (cycle - 0.5) * 2.6
+ }
+ bead.position.set(x, cycle < 0.5 ? 0.40 : 0.65, z)
+ })
+ }
+ if (id.includes('spin') && i >= 4 && i < 14 || id.includes('rope') && i === 9) {
+ point.visible = true
+ const angle = i < 6 ? 0 : -(t * Math.PI)
+ const radius = i < 6 ? 0.5 + pulse(t) * 1.6 : 2.15
+ const returning = id.includes('spin') && i === 13 ? 1 - smooth(u) : 1
+ point.position.set(Math.sin(angle) * radius * returning, 0.7 + Math.cos(angle) * 0.5, -Math.cos(angle) * radius * returning)
+ }
+ if (id.includes('rope') && i >= 11) {
+ const returning = i === 18 ? 1 - smooth(u) : i >= 19 ? 0 : 1
+ const lift = Math.min(1.65, (t - 1320) / 450) * returning
+ energy.root.position.y += Math.max(0, lift)
+ energy.arms.forEach((arm, n) => {
+ arm.rotation.x = -1.5 + Math.sin(t * (i >= 13 ? 7 : 4) + n * Math.PI) * 0.55 * returning
+ })
+ }
+ if (id.includes('roll') && i >= 6) {
+ const side = i === 8 ? 1 : -1
+ const returning = i === 13 ? 1 - smooth(u) : i >= 14 ? 0 : 1
+ const amplitude = i === 6 ? 0.2 : i < 10 ? 0.9 : 1.5
+ const roll = (0.5 - 0.5 * Math.cos((t % 8) / 8 * Math.PI * 2)) * returning
+ energy.root.position.x = side * roll * amplitude
+ energy.root.position.y += roll * 0.35
+ energy.root.rotation.y = side * roll * 1.7
+ }
+ // Keep the silver cord anchored in world space as the double moves.
+ cord.visible = energy.root.visible && energy.root.position.distanceTo(physical.root.position) > 0.15
+ const from = new T.Vector3(0, 0.57, 0)
+ const to = energy.root.position.clone().add(new T.Vector3(0, 0.12, 0))
+ const positions = cordGeometry.attributes.position
+ for (let n = 0; n < 25; n += 1) {
+ const v = n / 24
+ const p = from.clone().lerp(to, v)
+ p.y -= Math.sin(v * Math.PI) * 0.15
+ positions.setXYZ(n, p.x, p.y, p.z)
+ }
+ positions.needsUpdate = true
+ cordGeometry.computeBoundingSphere()
+ // In quiet preparation phases a breathing focus marks the body area
+ // addressed by the cue, rather than inventing muscular movement.
+ if (!point.visible && !current.visible && !rope.visible && !shaft.visible && !isReturn) {
+ ring.visible = true
+ const z = /Face|face/.test(state.phase) ? -1.18 : /Arms|arms/.test(state.phase) ? -0.45 : /Legs|legs/.test(state.phase) ? 0.65 : -0.45
+ ring.position.set(0, 0.66, z)
+ ring.scale.setScalar(0.8 + 0.2 * Math.sin(t * Math.PI / 3))
+ } else {
+ ring.scale.setScalar(1)
+ }
+ if (isReturn) {
+ energy.root.visible = false
+ current.visible = false
+ point.visible = false
+ ring.visible = false
+ }
+ return state
+ }
+ return { scene, camera, update }
+}
diff --git a/design/astral-projection/three/src/sessions.json b/design/astral-projection/three/src/sessions.json
new file mode 100644
index 000000000..6c87c64b5
--- /dev/null
+++ b/design/astral-projection/three/src/sessions.json
@@ -0,0 +1,502 @@
+[
+ {
+ "id": "bruce_foundation_touch",
+ "duration": 1200,
+ "title_key": "astral_practice_foundation_title",
+ "description_key": "astral_practice_foundation_description",
+ "guide_key": "astral_practice_foundation_guide",
+ "title": "Foundation Touch",
+ "cues": [
+ {
+ "second": 0,
+ "key": "astral_text_foundation_01",
+ "text": "Welcome. This is Foundation Touch, a preparation practice for Bruce-style body awareness. Sit comfortably or recline, with your hands resting palms down and your fingers slightly apart. Let your eyes close. You may briefly touch the target when I invite it, but otherwise let your physical body remain still. This is training, not a test. Tingling, warmth, pressure, or nothing at all are all acceptable."
+ },
+ {
+ "second": 120,
+ "key": "astral_text_foundation_02",
+ "text": "Choose your right hand. With one fingertip, lightly scratch a small circle on top of the joint where your thumb joins your hand. Make it about the size of a fingertip. Follow that touch closely. Then stop moving. Keep your attention on the exact place where the sensation remains. That remembered place is your target."
+ },
+ {
+ "second": 240,
+ "key": "astral_text_foundation_03",
+ "text": "Now stir that place with awareness alone. Feel a small clockwise circle moving through the skin, as if a soft pencil were turning there. Keep the circle close and simple. One or two turns each second is enough. If the motion loses its feel, slow down. Stay with touch rather than trying to see anything."
+ },
+ {
+ "second": 360,
+ "key": "astral_text_foundation_04",
+ "text": "Let response come or not come. Local heaviness, pressure, tingling, buzzing, or a bone-deep tickle may appear. None of it is required. If nothing happens, that is still useful training. Continue the little circle without pressing, without straining, and without asking for a particular result. Simply keep the feel of movement alive."
+ },
+ {
+ "second": 480,
+ "key": "astral_text_foundation_05",
+ "text": "Change to a gentle brushing action. Move awareness from just above the thumb joint, along the thumb, and to its tip. Then return through the same path. Feel the whole pathway each way. After a while, widen the stroke across the back of your hand and up to the wrist. Let motion itself hold your attention."
+ },
+ {
+ "second": 600,
+ "key": "astral_text_foundation_06",
+ "text": "Now imagine two hands made entirely of awareness. Send them to your left foot. Feel the whole foot, from toes to heel. Draw both awareness hands upward through the ankle, shin, knee, and thigh. When you reach the hip, instantly return to the toes. Stroke upward again. Do not drag awareness back down."
+ },
+ {
+ "second": 720,
+ "key": "astral_text_foundation_07",
+ "text": "Move to your right foot. Take a moment to feel its shape, sole, toes, and heel. Then draw your awareness hands slowly upward through the ankle, shin, knee, and thigh. Reach the hip, then flick back to the toes. Repeat these upward strokes at a speed that keeps the whole leg present to you."
+ },
+ {
+ "second": 840,
+ "key": "astral_text_foundation_08",
+ "text": "If both legs can stay clear, feel them together. As you stroke upward, imagine each awareness hand holding a large soft sponge. Draw a comfortable resistance upward through each leg, as though moving water upward through the whole limb. If one leg fades, work one leg at a time and alternate. Clarity matters more than doing both at once."
+ },
+ {
+ "second": 960,
+ "key": "astral_text_foundation_09",
+ "text": "When thought carries you away, name it gently: thought. Then return to the smallest felt action, one circle or one upward stroke. No result is not failure. If a limb stays blank, keep the movement going for a few more strokes, then change sides. Stop straining whenever effort becomes physical tension."
+ },
+ {
+ "second": 1080,
+ "key": "astral_text_foundation_10",
+ "text": "Let the awareness hands settle at your sides. Feel your whole body breathing. Begin small movement: swallow, wiggle your fingers, move your feet. Before you stand, recall which side responded most easily, what sensations appeared, and where attention wandered. Write those keywords now or immediately after you finish."
+ }
+ ]
+ },
+ {
+ "id": "bruce_full_body_current",
+ "duration": 1500,
+ "title_key": "astral_practice_current_title",
+ "description_key": "astral_practice_current_description",
+ "guide_key": "astral_practice_current_guide",
+ "title": "Full-Body Current",
+ "cues": [
+ {
+ "second": 0,
+ "key": "astral_text_current_01",
+ "text": "Welcome to Full-Body Current. Lie on your back, or recline comfortably, and let your arms rest at your sides. Close your eyes and let your body settle. In this practice, movement happens in awareness, not muscles. Keep breathing naturally. We will first test rhythm, then bounce, then draw upward, and finally follow one slow circuit with the breath."
+ },
+ {
+ "second": 120,
+ "key": "astral_text_current_02",
+ "text": "Bring awareness into your right leg. Move it rapidly from foot to hip and back, feeling the pathway in both directions. Gradually increase speed until the movement seems to meet a soft dragging feeling. Then slow slightly. That sustainable rhythm is your bounce. It is not counted or timed by the clock; it is found by contact and comfort."
+ },
+ {
+ "second": 240,
+ "key": "astral_text_current_03",
+ "text": "Keep bouncing through the right leg. Feel every passage between foot and hip. Now change to the left leg and find its rhythm. If both legs can remain clear, bounce them together, foot to hip and back. If one side fades, alternate. Let each bounce be smooth and continuous."
+ },
+ {
+ "second": 360,
+ "key": "astral_text_current_04",
+ "text": "Move awareness into your right hand. Bounce from fingertips, through the hand and arm, to the shoulder, and back. Find the same gentle resistance, then settle into rhythm. Change to the left arm. If possible, feel both arms together. Keep your shoulders loose and your jaw soft."
+ },
+ {
+ "second": 480,
+ "key": "astral_text_current_05",
+ "text": "Now slow down. Feel an awareness hand holding a large soft sponge at each foot. Draw upward through the whole of both legs, over the front of the hips, and into the lower belly, midway between navel and pubic line. Flick back to the feet. Repeat each upward sweep in two or three comfortable seconds."
+ },
+ {
+ "second": 600,
+ "key": "astral_text_current_06",
+ "text": "Move to your hands. Draw awareness through each whole arm, into the shoulders, down across the chest and stomach, and into the same lower-belly area. Then flick back to the hands. Let the action be wide and spongy rather than narrow and precise. If both arms cannot stay clear, alternate arms."
+ },
+ {
+ "second": 720,
+ "key": "astral_text_current_07",
+ "text": "Let awareness rest in both feet. With your next natural in-breath, draw upward through both legs and the back, through the hips and spine, to the back of the neck. Continue to the crown. At the top, briefly gather awareness before the out-breath begins. Keep the path broad and comfortable."
+ },
+ {
+ "second": 840,
+ "key": "astral_text_current_08",
+ "text": "As you breathe out, sweep awareness over the crown and face, down over the chest and stomach, into the lower belly. At the end of the out-breath, instantly return to both feet. Breathe in, and rise again. Let the breath provide rhythm. Do not force its depth. Simple, slow, and natural is enough."
+ },
+ {
+ "second": 960,
+ "key": "astral_text_current_09",
+ "text": "Continue the circuit. Feel the upward current through feet, legs, and back. At the crown, do not linger too long. On the out-breath, descend like a slow wave to the lower belly. If the mouth or throat detail distracts you, simply pass over face and chest. The broad current matters more than any small segment."
+ },
+ {
+ "second": 1080,
+ "key": "astral_text_current_10",
+ "text": "If the circuit becomes complicated, simplify. Breathe in and rise from feet to crown. Breathe out and descend to the lower belly. Nothing else is required. If breath awareness makes you tense, let the same current continue at a natural rhythm without counting. Return to the breath only when you soften."
+ },
+ {
+ "second": 1200,
+ "key": "astral_text_current_11",
+ "text": "Take a few last easy rounds. Let each rise be felt through the whole body. Let each descent end low and quiet. If sensations become intense or uncomfortable, stop the circuit and rest with ordinary breathing. This practice should remain gentle and repeatable."
+ },
+ {
+ "second": 1320,
+ "key": "astral_text_current_12",
+ "text": "Let the circuit dissolve. Feel the bed or chair holding you. Notice ordinary breathing without changing it. Move your fingers and toes, stretch if you wish, and let your eyes open naturally. Before doing anything else, note the clearest pathway, strongest sensation, and any place where awareness skipped."
+ },
+ {
+ "second": 1440,
+ "key": "astral_text_current_13",
+ "text": "This completes Full-Body Current. You have practiced finding rhythm, moving awareness through limbs, and following one complete circuit. Keep your notes brief and factual. In later sessions, choose the same practice again, or move to Elevator Descent when you feel steady."
+ }
+ ]
+ },
+ {
+ "id": "bruce_elevator_trance",
+ "duration": 1800,
+ "title_key": "astral_practice_elevator_title",
+ "description_key": "astral_practice_elevator_description",
+ "guide_key": "astral_practice_elevator_guide",
+ "title": "Elevator Descent",
+ "cues": [
+ {
+ "second": 0,
+ "key": "astral_text_elevator_01",
+ "text": "Welcome to Elevator Descent. Settle into a comfortable reclining or lying position and close your eyes. Let your body become sleepy and heavy while a small part of attention stays quietly awake. You do not need perfect silence, perfect comfort, or any special sensation. If you fall asleep, let yourself wake naturally; when you do, record what you remember."
+ },
+ {
+ "second": 120,
+ "key": "astral_text_elevator_02",
+ "text": "Bring attention to your face. Let your forehead broaden. Let your eyelids rest. Unclench your jaw and let your tongue lie easily. Allow your breath to move without control. Let the back of your neck lengthen. Let your shoulders fall away. There is nowhere to reach and nothing to achieve in this first phase."
+ },
+ {
+ "second": 240,
+ "key": "astral_text_elevator_03",
+ "text": "Let heaviness move down through your arms, elbows, wrists, and hands. Feel your chest rise and fall by itself. Soften your belly. Let your back sink into its support. If a place holds tension, breathe toward it once, then allow it to remain as it softens in its own time."
+ },
+ {
+ "second": 360,
+ "key": "astral_text_elevator_04",
+ "text": "Let your hips grow wide and heavy. Let your thighs release. Let your knees fall naturally. Let the feeling continue through your calves, ankles, and feet. From crown to toes, allow your body to be completely held. If you need to adjust, move once, slowly, and then settle again."
+ },
+ {
+ "second": 480,
+ "key": "astral_text_elevator_05",
+ "text": "Now let thoughts lose their urgency. If a plan or concern calls, hold it for one moment and say inwardly: noted. Imagine setting it just outside the elevator door. You may return to it later. If thoughts continue, let them pass like voices in another corridor. Your attention does not need to argue with them."
+ },
+ {
+ "second": 600,
+ "key": "astral_text_elevator_06",
+ "text": "Rest a small, steady part of attention at the nostrils or the movement of your chest. Feel air enter. Feel air leave. Do not deepen or shape the breath. When the mind wanders, return with the next out-breath. This simple contact is enough to keep you quietly present while the body continues to let go."
+ },
+ {
+ "second": 720,
+ "key": "astral_text_elevator_07",
+ "text": "Imagine standing in a simple elevator. One side is open to a dark stone shaft. You are safe and supported. The elevator begins to move down. Feel that downward movement in your body, perhaps as a soft lowering in the stomach or a general settling. Let the rough stone surface pass upward as you descend."
+ },
+ {
+ "second": 840,
+ "key": "astral_text_elevator_08",
+ "text": "The image can remain incomplete. You do not need clear pictures. Return to felt movement: down, down, down. If a remembered elevator sensation arises, borrow it. If nothing visual appears, continue with the body feeling of lowering. Let every imagined detail stay simple and unimportant compared with the felt descent."
+ },
+ {
+ "second": 960,
+ "key": "astral_text_elevator_09",
+ "text": "If counting helps, notice a soft floor number as you pass. One. Two. Three. Let each number arrive on an out-breath and fade. Do not rush to a target floor. If counting becomes busy, drop it and feel only the elevator moving downward. If you lose the scene, begin again at the next breath."
+ },
+ {
+ "second": 1080,
+ "key": "astral_text_elevator_10",
+ "text": "A wave of warmth or heaviness may pass through the body. In Bruce's model, this is a sign of trance entry. It does not need to be dramatic. When it comes, stop adding effort. Breathe naturally. Let the elevator become very slow or pause. Rest with breath awareness and allow the heavy feeling to stabilize."
+ },
+ {
+ "second": 1200,
+ "key": "astral_text_elevator_11",
+ "text": "If the mind becomes fuzzy, do not grip. Keep one quiet thread of attention at the breath. If imagery, sound, or drifting thought appears, let it move without following it. Your body can continue to sleep downward while your awareness remains lightly present. Not too tight. Not too loose."
+ },
+ {
+ "second": 1320,
+ "key": "astral_text_elevator_12",
+ "text": "If you remain clear and want more depth, let the elevator move down again. One easy floor. One felt lowering. If sleep presses close, stop descending. Return to breath and simply hold the state you have. A stable light state is more useful for later practice than forcing a deeper one."
+ },
+ {
+ "second": 1440,
+ "key": "astral_text_elevator_13",
+ "text": "If a sound arrives, let it be part of the background. Do not brace against it. Let it arise and fade like a distant floor bell. If discomfort grows, adjust slowly and deliberately, then resettle. If genuine uneasiness remains, end the descent and return. You can always practice again."
+ },
+ {
+ "second": 1560,
+ "key": "astral_text_elevator_14",
+ "text": "Let the elevator pause. Let the stone shaft fade. Let the feeling of downward movement stop. Keep your eyes closed and feel ordinary breathing. Notice the room around your body, the support beneath you, and the heaviness still present. Let wakefulness return gently, at its own pace."
+ },
+ {
+ "second": 1680,
+ "key": "astral_text_elevator_15",
+ "text": "Now bring small movement back. Wiggle your fingers and toes. Move your ankles and wrists. Stretch if that feels good. Open your eyes when you are ready. Immediately recall the moment of deepest heaviness, the first sign of fuzziness, and any thoughts that pulled you away. Record those keywords while they remain fresh."
+ }
+ ]
+ },
+ {
+ "id": "bruce_spin_loosening",
+ "duration": 1800,
+ "title_key": "astral_practice_spin_title",
+ "description_key": "astral_practice_spin_description",
+ "guide_key": "astral_practice_spin_guide",
+ "title": "Room Spin",
+ "cues": [
+ {
+ "second": 0,
+ "key": "astral_text_spin_01",
+ "text": "Welcome to Room Spin. This is a loosening preparation, not an exit attempt. Its aim is to practice holding a moving point of awareness outside your physical body. Lie down or recline safely. Let the room be familiar. If strong vertigo, fear, or unwellness appears, stop and return to ordinary breathing."
+ },
+ {
+ "second": 120,
+ "key": "astral_text_spin_02",
+ "text": "With eyes closed, remember the room. Sense the wall or ceiling before your face. Sense the surface to your right, the surface to your left, the space behind you, and the support beneath. You do not need perfect detail. This is only a spatial map. Let it stay broad and calm."
+ },
+ {
+ "second": 240,
+ "key": "astral_text_spin_03",
+ "text": "Let your face soften. Let your jaw, throat, and shoulders release. Let each arm grow heavy. Let your chest and belly move with easy breath. Let your hips, legs, and feet sink. Move once if needed, then settle. This practice needs a deeply relaxed body and a quietly awake mind."
+ },
+ {
+ "second": 360,
+ "key": "astral_text_spin_04",
+ "text": "Use easy breath awareness. As your body grows heavier, let thoughts become less verbal. If a concern appears, note it and let it pass. You may feel warm, fuzzy, distant from the room, or simply deeply rested. Stay awake enough to know where your attention is placed."
+ },
+ {
+ "second": 480,
+ "key": "astral_text_spin_05",
+ "text": "Now place a small point of awareness before your face, at eye level. Let it touch the wall or ceiling directly in front of you, then return to your starting position. Again, forward and back. Keep the movement gentle and continuous. The point is not your eyes and not your muscles; it is a moving place of attention."
+ },
+ {
+ "second": 600,
+ "key": "astral_text_spin_06",
+ "text": "As the point touches each surface, briefly imagine being close to it. Texture, temperature, and distance can remain vague. What matters is the momentary change of position. Let physical sensation slide into the background. If you become too aware of the body, relax once more, then resume the moving point."
+ },
+ {
+ "second": 720,
+ "key": "astral_text_spin_07",
+ "text": "From the point before your face, move clockwise. Brush the right side of the room, then the space behind you, then the left side, then return to the point before your face. Let the circuit include ceiling or wall, side surfaces, floor or bed, and back. Move smoothly, without forcing speed."
+ },
+ {
+ "second": 840,
+ "key": "astral_text_spin_08",
+ "text": "Let each full circuit take about one to three seconds, or whatever feels natural. Faster is not better. Keep contact with each surface as you pass. If the movement skips, slow down. If the room becomes uncertain, rebuild the broad map and continue. Movement is easier to hold than a fixed point outside the body."
+ },
+ {
+ "second": 960,
+ "key": "astral_text_spin_09",
+ "text": "As awareness circles, notice that perspective changes. From the right side, the body lies to the left. From behind, the body is before you. From the left, the body lies right. You need not see this clearly; feel the changing relation. Each pass briefly accepts a position that is not centered in the physical body."
+ },
+ {
+ "second": 1080,
+ "key": "astral_text_spin_10",
+ "text": "Let the physical body remain safe, heavy, and increasingly distant. Do not inspect its sensations. Keep attention on the moving point and the surfaces it touches. If tingling, lightness, dizziness, or brief falling feelings arise, remain calm and continue only if you feel steady. Otherwise slow to breath and end."
+ },
+ {
+ "second": 1200,
+ "key": "astral_text_spin_11",
+ "text": "Continue in one steady rhythm. Around the room, again and again. If attention drops back into the body, send the point gently forward and resume the clockwise circle. If monotony makes you drowsy, slightly vary the size of the circle while keeping direction and movement. Do not turn this into effort."
+ },
+ {
+ "second": 1320,
+ "key": "astral_text_spin_12",
+ "text": "Release any demand for images. Some people see shadows or surfaces; many feel only position and movement. Both are workable. If an image contradicts the room you know, let it pass without analysis. This is training in exterior perspective, not a test of clairvoyance or accuracy."
+ },
+ {
+ "second": 1440,
+ "key": "astral_text_spin_13",
+ "text": "If movement feels unusually strong, remember that this session remains preparation. Do not add an exit technique now. Let the circle slow. Return to easy breath. Keep the body limp. If the state remains comfortable, you may continue a few more easy circuits, then finish within this session."
+ },
+ {
+ "second": 1560,
+ "key": "astral_text_spin_14",
+ "text": "Let the circle grow slower and wider. Bring the point before your face. Let it dissolve. Feel ordinary breath in the chest or nostrils. Notice the support beneath your body. Let awareness gather behind your closed eyes, then through the whole physical body. Rest here without rushing."
+ },
+ {
+ "second": 1680,
+ "key": "astral_text_spin_15",
+ "text": "Bring movement back gradually. Wiggle fingers and toes, then ankles and wrists. Turn or stretch slowly. Open your eyes when ready. Record the circuit speed that stayed clear, the direction and surface easiest to feel, and any moment when perspective truly changed. Note anything uncomfortable so the next setup can be adjusted."
+ }
+ ]
+ },
+ {
+ "id": "bruce_rope_exit",
+ "duration": 2400,
+ "title_key": "astral_practice_rope_title",
+ "description_key": "astral_practice_rope_description",
+ "guide_key": "astral_practice_rope_guide",
+ "title": "Rope Exit",
+ "cues": [
+ {
+ "second": 0,
+ "key": "astral_text_rope_01",
+ "text": "Welcome to Rope Exit. This is the main active attempt in this draft set. Its purpose, in Bruce's model, is to hold exterior awareness strongly enough to trigger a projection response. Prepare as though for sleep, but keep a thread of intention awake. If you feel unwell, unusually anxious, or unsafe, stop and practice a preparation session instead."
+ },
+ {
+ "second": 120,
+ "key": "astral_text_rope_02",
+ "text": "Settle into your chosen posture. If you prepared a soft rope aid above your chest, briefly touch its position and remember how it feels. Then let your hand rest. The real rope in this practice is imaginary. Place it above the center of your chest, within easy reach. Let its angle adjust naturally to your posture."
+ },
+ {
+ "second": 240,
+ "key": "astral_text_rope_03",
+ "text": "Close your eyes. Smooth your forehead. Let your eyelids become still. Let your jaw loosen and your tongue rest. Soften your throat and the back of your neck. Let your shoulders fall. Let each arm grow heavier, through elbow, wrist, hand, and fingertips. Keep breathing naturally."
+ },
+ {
+ "second": 360,
+ "key": "astral_text_rope_04",
+ "text": "Let your chest move without control. Let your belly soften. Let your back settle into its support, vertebra by vertebra. If a place remains tense, do not fight it. Breathe toward it, then let time and gravity do the work. Deep physical relaxation is not a preliminary here; it is central to the method."
+ },
+ {
+ "second": 480,
+ "key": "astral_text_rope_05",
+ "text": "Let your hips widen and sink. Let both thighs release. Let your knees fall comfortably apart or supported. Let heaviness continue through calves, ankles, soles, and toes. From crown to toes, your body is safe and heavy. If you must adjust, move once slowly, then settle again."
+ },
+ {
+ "second": 600,
+ "key": "astral_text_rope_06",
+ "text": "Let thoughts become quieter. Set aside plans with one inner word: later. Rest attention at the breath. Feel air enter and leave. Do not control it. If a thought pulls you, return with the next out-breath. Let the body continue toward sleep while a small thread of awareness remains clear."
+ },
+ {
+ "second": 720,
+ "key": "astral_text_rope_07",
+ "text": "If it helps you settle, imagine a slow elevator moving downward. Feel the lowering in your body. Let one floor pass. Let another pass. When heaviness or warmth arrives, stop adding imagery. Keep breath awareness. You want enough depth for the body to sleep, but enough clarity to act."
+ },
+ {
+ "second": 840,
+ "key": "astral_text_rope_08",
+ "text": "Bring awareness into both feet. Brush across the toes and through the soles until the feet feel present, even if no sensation appears. Draw upward through each leg to the hip, then return to the feet. Move to your hands. Brush through fingers and palms, then draw through each arm to the shoulder."
+ },
+ {
+ "second": 960,
+ "key": "astral_text_rope_09",
+ "text": "Now use a few easy full-body circuits. Breathe in, and draw awareness from feet through legs and back to the crown. Breathe out, and sweep down over face and chest into the lower belly. Return to the feet. Keep the action broad and gentle. Stop before it becomes tense or exhausting."
+ },
+ {
+ "second": 1080,
+ "key": "astral_text_rope_10",
+ "text": "For a few minutes, loosen exterior awareness. Send a point before your face, touch the wall or ceiling, and return through the body. Or move the point slowly around the room. Let physical sensation move into the background. Keep the body limp. This is optional pressure, not the main exit yet."
+ },
+ {
+ "second": 1200,
+ "key": "astral_text_rope_11",
+ "text": "Now make the intention simple. If separation occurs, stay calm, keep the session brief, return promptly, and record everything. Do not extend a first success. Feel the possibility of moving upward and away, with your physical body safely behind you. Then let that rehearsal go. Only the rope remains."
+ },
+ {
+ "second": 1320,
+ "key": "astral_text_rope_12",
+ "text": "Feel a strong rope hanging above your chest. Reach out with both awareness hands and grasp it. Feel texture, weight, and grip only as much as helps. Let one hand hold while the other reaches higher. Then pull. The rope comes toward your chest as your felt body rises."
+ },
+ {
+ "second": 1440,
+ "key": "astral_text_rope_13",
+ "text": "Climb hand over hand. One awareness hand reaches while the other holds. Pull. Reach. Pull. Feel yourself moving upward along the rope while your physical body remains behind and limp. Keep your neck, shoulders, and arms relaxed, and let breathing continue naturally. The climbing happens entirely as felt body-awareness action."
+ },
+ {
+ "second": 1560,
+ "key": "astral_text_rope_14",
+ "text": "Increase speed until the action meets a sense of resistance, then ease back to a strong natural rhythm. One complete reach and pull might take half a second to one second. Do not climb so slowly that pressure fades. Do not move so fast that your awareness skips the rope. Keep both hands working together."
+ },
+ {
+ "second": 1680,
+ "key": "astral_text_rope_15",
+ "text": "Dizziness in the chest or stomach, localized pressure, buzzing, heaviness, warmth, or a sense of movement may appear. In Bruce's model these can indicate exit pressure. They are not goals. Do not inspect them. Keep climbing. If genuine distress or disorientation appears, stop calmly, rest, and end the session."
+ },
+ {
+ "second": 1800,
+ "key": "astral_text_rope_16",
+ "text": "If thoughts arise, return to the next reach. If the rope becomes vague, feel the pull alone. If sensations grow strong, remain calm and continue only while you feel safe. Do not analyze the process. Do not wonder whether it is working. Reach, hold, pull, rise. This one action fills the mind."
+ },
+ {
+ "second": 1920,
+ "key": "astral_text_rope_17",
+ "text": "Check without checking: your jaw is loose. Your shoulders are down. Your arms do not move. Your breath remains natural. If the breath has become shallow or held, let it resume. If any muscle has tightened, let it release. Then climb again, strongly and quietly, hand over hand."
+ },
+ {
+ "second": 2040,
+ "key": "astral_text_rope_18",
+ "text": "If you feel partly lifted, stuck near the body, or only a limb free, do not pull back in alarm. Continue the rope, or switch smoothly to a rolling whole-body movement if that feels more natural. Do not open physical eyes. Keep the physical body motionless while the felt body completes its motion away."
+ },
+ {
+ "second": 2160,
+ "key": "astral_text_rope_19",
+ "text": "If separation seems to occur, remain calm. Keep the experience deliberately short. Move only a little away, note where you are, and choose to return promptly. Let reentry happen. Do not struggle to reconstruct the experience while it is still unfolding. Quietly say inwardly: I remember clearly."
+ },
+ {
+ "second": 2280,
+ "key": "astral_text_rope_20",
+ "text": "Let the rope disappear. Let all technique end. Feel ordinary breath and physical support. Move fingers and toes, then ankles and wrists. Open your eyes gradually. Immediately write keywords: rope feel, rhythm, signs, any separation, return, and the first memory that arrives. Do not wait to make a polished story."
+ }
+ ]
+ },
+ {
+ "id": "bruce_roll_out_exit",
+ "duration": 1800,
+ "title_key": "astral_practice_roll_out_title",
+ "description_key": "astral_practice_roll_out_description",
+ "guide_key": "astral_practice_roll_out_guide",
+ "title": "Roll Out",
+ "cues": [
+ {
+ "second": 0,
+ "key": "astral_text_roll_out_01",
+ "text": "Welcome to Roll-Out Exit. Unlike Room Spin, this is an exit attempt. You will recreate the whole-body feeling of rolling and twisting to one side, away from your physical body. First you will prepare. Then you will practice both sides. If uneasiness or unwellness grows, stop and return to breath."
+ },
+ {
+ "second": 120,
+ "key": "astral_text_roll_out_02",
+ "text": "Lie safely with space to either side, or settle in a recliner. Keep your physical body still. The imagined movement may feel energetic or subtle; do not let your muscles imitate it. Your eyes remain closed. If separation occurs, keep it short, return promptly, and record keywords immediately."
+ },
+ {
+ "second": 240,
+ "key": "astral_text_roll_out_03",
+ "text": "Let your face soften. Let jaw, neck, and shoulders release. Let both arms become heavy. Let your chest and belly move naturally. Let your hips, legs, and feet sink. From the top of your head to your soles, allow complete support. Move once if necessary, then become still."
+ },
+ {
+ "second": 360,
+ "key": "astral_text_roll_out_04",
+ "text": "Rest attention at the breath. Air enters. Air leaves. Let thought grow quiet. Let the body grow warmer, heavier, and more distant. You want a light, stable trance: enough depth that the body is asleep-like, enough clarity that you can choose a direction and move awareness."
+ },
+ {
+ "second": 480,
+ "key": "astral_text_roll_out_05",
+ "text": "Brush awareness through both feet and hands. Draw upward through legs to hips and arms to shoulders. Follow a few easy full-body circuits: rise from feet to crown on the in-breath, descend over face and chest to the lower belly on the out-breath. Keep the action gentle and stop before strain."
+ },
+ {
+ "second": 600,
+ "key": "astral_text_roll_out_06",
+ "text": "Let energy work fade. Return to breath. Let heaviness deepen again. Let the sense of your physical body become broad and less insistent. When you feel settled, remember that the upcoming roll is a whole-body awareness action, not a twist of muscles and not a visual picture."
+ },
+ {
+ "second": 720,
+ "key": "astral_text_roll_out_07",
+ "text": "Feel your body as one shape from head to feet. Do not divide it into parts. Imagine that entire shape beginning to turn. The head, shoulders, chest, hips, legs, and feet all roll together. No joint leads. No muscle tightens. The whole felt body moves as one continuous body."
+ },
+ {
+ "second": 840,
+ "key": "astral_text_roll_out_08",
+ "text": "Begin rolling slowly to your left. Feel twist and sideways movement together. Roll away from your physical position, not merely onto an arm. Pause. Return to center. Roll left again. Let the movement be complete, from crown through feet. If the left feels awkward, note it and rest."
+ },
+ {
+ "second": 960,
+ "key": "astral_text_roll_out_09",
+ "text": "Now return to center. Roll the whole felt body to your right. Again, feel twist and roll together. Away from center. Pause. Return. Repeat. Compare this side with the other. Choose whichever side gives the stronger sense of whole-body movement away from where you lie."
+ },
+ {
+ "second": 1080,
+ "key": "astral_text_roll_out_10",
+ "text": "Choose your clearer direction. Let the roll become more confident. Roll away, return just enough to repeat, then roll away again. Keep the physical body limp. Keep the movement whole. Do not imagine a separate pair of hands pulling you; this method uses the entire body's felt motion."
+ },
+ {
+ "second": 1200,
+ "key": "astral_text_roll_out_11",
+ "text": "Now let the roll carry farther. Do not rush. Feel yourself twisting beyond the body's position and away. Keep your eyes closed. Keep your breath natural. Fill attention with the whole-body roll. In Bruce's approach, resolve and enthusiasm matter, but they must remain mentally strong while the body stays relaxed."
+ },
+ {
+ "second": 1320,
+ "key": "astral_text_roll_out_12",
+ "text": "Heaviness, lightness, pressure, tingling, vertigo, or movement feelings may arise. Do not stop to examine them. Continue the roll. If sensations become intense, stay calm and only continue if you feel safe. If genuine distress appears, stop technique, breathe normally, and end the attempt."
+ },
+ {
+ "second": 1440,
+ "key": "astral_text_roll_out_13",
+ "text": "If you feel partly out or stuck close to the physical body, do not pull back in panic. Roll farther to the clearer side. Let the whole felt body complete the movement away. If a limb seems free, bring the entire body with it. Keep physical muscles completely still."
+ },
+ {
+ "second": 1560,
+ "key": "astral_text_roll_out_14",
+ "text": "If separation seems complete, remain calm and make the experience brief. Note your position, then choose to return directly to the body. Do not linger to explore. Let reentry happen. As you return, say inwardly: I remember clearly. Then let memory settle without forcing."
+ },
+ {
+ "second": 1680,
+ "key": "astral_text_roll_out_15",
+ "text": "Let rolling end. Feel ordinary breath and the support beneath you. Wiggle fingers and toes, then move wrists and ankles. Stretch slowly and open your eyes. Immediately write: clearer side, roll strength, signs, partial separation, return, and any image or movement remembered. Keywords first; interpretation later."
+ }
+ ]
+ }
+]
diff --git a/design/astral-projection/three/src/timeline.js b/design/astral-projection/three/src/timeline.js
new file mode 100644
index 000000000..e59cc9c28
--- /dev/null
+++ b/design/astral-projection/three/src/timeline.js
@@ -0,0 +1,16 @@
+export const phases = {
+ bruce_foundation_touch: ['Settle', 'Touch right thumb joint', 'Clockwise stirring', 'Continue stirring', 'Brush thumb and wrist', 'Left leg upward strokes', 'Right leg upward strokes', 'Both legs · sponge upward', 'Gentle strokes', 'Return and recall'],
+ bruce_full_body_current: ['Settle', 'Right leg bounce', 'Left then both legs', 'Arm bounce', 'Feet to lower belly', 'Hands to lower belly', 'Inhale · feet to crown', 'Exhale · crown to belly', 'Full circuit', 'Simplify circuit', 'Last rounds', 'Return', 'Recall'],
+ bruce_elevator_trance: ['Settle', 'Face release', 'Arms release', 'Legs release', 'Quiet thoughts', 'Breath anchor', 'Elevator descends', 'Felt descent', 'Passing floors', 'Pause · heaviness', 'Rest at breath', 'One more easy floor', 'Stay comfortable', 'Stop descent · return', 'Movement and recall'],
+ bruce_spin_loosening: ['Settle', 'Room map', 'Release body', 'Breath anchor', 'Point forward and back', 'Touch the surface', 'Clockwise circuit', 'Steady circuit', 'Changing perspective', 'Body remains still', 'Steady rhythm', 'Felt position', 'Slow the circle', 'Point returns', 'Movement and recall'],
+ bruce_rope_exit: ['Settle', 'Safe setup', 'Face release', 'Arms release', 'Legs release', 'Breath anchor', 'Optional descent', 'Brush limbs', 'Full circuit', 'Exterior point', 'Brief intention', 'Grasp rope', 'Hand over hand', 'Natural climbing rhythm', 'Continue gently', 'Reach · hold · pull', 'Release physical tension', 'Complete lift', 'Brief separation · return', 'Ground and recall'],
+ bruce_roll_out_exit: ['Settle', 'Safe setup', 'Release body', 'Breath anchor', 'Energy circuit', 'Rest', 'Whole body turning', 'Roll left', 'Roll right', 'Choose clearer side', 'Roll farther', 'Continue gently', 'Complete roll', 'Brief separation · return', 'Ground and recall'],
+}
+
+export function sample(item, seconds) {
+ const time = Math.max(0, Math.min(item.duration, seconds))
+ const index = item.cues.findLastIndex(cue => cue.second <= time)
+ const cue = item.cues[index]
+ const end = item.cues[index + 1]?.second ?? item.duration
+ return { time, index, cue, progress: (time - cue.second) / (end - cue.second), phase: phases[item.id][index] }
+}
diff --git a/design/astral-projection/three/style.css b/design/astral-projection/three/style.css
new file mode 100644
index 000000000..e2126d8a8
--- /dev/null
+++ b/design/astral-projection/three/style.css
@@ -0,0 +1,28 @@
+:root { color-scheme: dark; font-family: system-ui, sans-serif; background: #090f1c; color: #e6edf4; }
+* { box-sizing: border-box; }
+body { margin: 0; }
+main { max-width: 1100px; margin: auto; padding: 28px 24px; }
+header { padding: 10px 0 22px; }
+h1 { font-family: Georgia, serif; font-size: clamp(26px,4vw,42px); font-weight: 400; margin: 10px 0; }
+header p, footer { color: #9cacc2; }
+.eyebrow { color: #8cd4dd; letter-spacing: .14em; font-size: 11px; }
+.stage { position: relative; border: 1px solid #263448; border-radius: 20px; overflow: hidden; background: #0b1424; }
+canvas { display: block; width: 100%; height: 460px; }
+.legend { position: absolute; left: 20px; top: 18px; display: flex; gap: 20px; font-size: 12px; color: #e0ad8b; }
+.legend span + span { color: #72dcf0; }
+#phase { position: absolute; bottom: 18px; left: 20px; font-family: Georgia, serif; font-size: 22px; }
+.controls { padding: 22px 0 12px; }
+label { font-size: 12px; color: #9cacc2; }
+select,button { border: 1px solid #38475b; border-radius: 8px; background: #152237; color: #e6edf4; padding: 10px 13px; min-height: 44px; }
+#exercise { margin-left: 12px; max-width: 80%; }
+.transport { display: flex; align-items: center; gap: 10px; margin: 16px 0; }
+output { margin-left: auto; font-variant-numeric: tabular-nums; font-size: 13px; }
+.seek { display: block; }
+input { width: 100%; accent-color: #8cd4dd; min-height: 30px; }
+#markers { display: flex; flex-wrap: wrap; gap: 5px; }
+#markers button { font-size: 11px; padding: 5px 8px; min-height: 32px; }
+#markers button[aria-current=true] { border-color: #8cd4dd; color: #8cd4dd; }
+.caption { border-top: 1px solid #263448; padding-top: 18px; min-height: 170px; }
+#caption { line-height: 1.75; font-size: 16px; margin: 10px 0 20px; }
+footer { font-size: 11px; line-height: 1.6; max-width: 760px; }
+@media(max-width:600px) { main { padding: 16px; } canvas { height: 370px; } .legend { font-size: 9px; gap: 12px; } .transport { flex-wrap: wrap; } #phase { font-size: 18px; } }
diff --git a/design/astral-projection/three/tools/sync-data.py b/design/astral-projection/three/tools/sync-data.py
new file mode 100644
index 000000000..c400d8c1f
--- /dev/null
+++ b/design/astral-projection/three/tools/sync-data.py
@@ -0,0 +1,15 @@
+"""Snapshot only the six canonical sessions and their English caption text."""
+import json
+import pathlib
+import re
+
+root = pathlib.Path(__file__).resolve().parents[4]
+source = root.parent.parent / 'modules/practices/astral_projection'
+texts = dict(re.findall(r'\[([^\]]+)\]\n(.*?)\n---', (source / 'text/en.txt').read_text(), re.S))
+items = json.loads((source / 'catalogue.json').read_text())['practices']
+for item in items:
+ session = json.loads((source / 'sessions' / (item['id'] + '.json')).read_text())
+ assert item['duration'] == session['duration']
+ item['title'] = texts[item['title_key']]
+ item['cues'] = [dict(cue, text=texts[cue['key']]) for cue in session['cues']]
+(root / 'design/astral-projection/three/src/sessions.json').write_text(json.dumps(items, ensure_ascii=False, indent=2) + '\n')
diff --git a/design/astral-projection/three/tools/verify.mjs b/design/astral-projection/three/tools/verify.mjs
new file mode 100644
index 000000000..0585a3edf
--- /dev/null
+++ b/design/astral-projection/three/tools/verify.mjs
@@ -0,0 +1,148 @@
+// Integration test: launch ONLY an owned private X server and browser.
+import { spawn } from 'node:child_process'
+import { mkdirSync, readFileSync, writeFileSync, existsSync, rmSync, mkdtempSync } from 'node:fs'
+import { resolve, join } from 'node:path'
+import assert from 'node:assert/strict'
+import { startServer, INBE_ROOT } from '../../../promo-film/three/tools/serve.mjs'
+import { sample, phases } from '../src/timeline.js'
+
+const root = INBE_ROOT
+const out = join(root, 'build/astral-threejs')
+mkdirSync(out, { recursive: true })
+const temp = join(root, 'build/atmp')
+mkdirSync(temp, { recursive: true })
+const env = { ...process.env, TMPDIR: temp, HARMONY_DESKTOP_RECOVERY: '0' }
+for (const key of ['DISPLAY', 'WAYLAND_DISPLAY', 'XAUTHORITY', 'DBUS_SESSION_BUS_ADDRESS', 'SESSION_MANAGER']) delete env[key]
+const items = JSON.parse(readFileSync(join(root, 'design/astral-projection/three/src/sessions.json')))
+const source = resolve(root, '../../modules/practices/astral_projection')
+const text = Object.fromEntries([...readFileSync(join(source, 'text/en.txt'), 'utf8').matchAll(/\[([^\]]+)\]\n(.*?)\n---/gs)].map(m => [m[1], m[2]]))
+const catalogue = JSON.parse(readFileSync(join(source, 'catalogue.json'))).practices
+assert.equal(JSON.parse(readFileSync(join(root, 'design/promo-film/three/node_modules/three/package.json'))).version, '0.169.0')
+assert.equal(items.length, 6)
+for (const [n, item] of items.entries()) {
+ assert.equal(item.id, catalogue[n].id)
+ const session = JSON.parse(readFileSync(join(source, 'sessions', `${item.id}.json`)))
+ assert.equal(item.duration, session.duration)
+ assert.equal(phases[item.id].length, session.cues.length)
+ assert.deepEqual(item.cues.map(({ second, key }) => ({ second, key })), session.cues)
+ for (const [i, cue] of item.cues.entries()) {
+ assert.equal(cue.text, text[cue.key])
+ assert.equal(sample(item, cue.second).index, i)
+ if (i) assert.equal(sample(item, cue.second - 0.001).index, i - 1)
+ }
+ assert.equal(sample(item, item.duration + 1).time, item.duration)
+}
+const { server } = await startServer()
+const port = server.address().port
+const profile = mkdtempSync(join(temp, 'c-'))
+const browser = spawn('xvfb-run', ['-a', 'chromium', '--headless=new', '--use-angle=swiftshader', '--enable-unsafe-swiftshader', '--no-first-run', '--no-default-browser-check', '--disable-extensions', '--remote-allow-origins=*', '--remote-debugging-port=0', `--user-data-dir=${profile}`, '--window-size=1100,1000', 'about:blank'], { env, stdio: ['ignore', 'ignore', 'pipe'] })
+let diagnostics = ''
+browser.stderr.on('data', bytes => { diagnostics = (diagnostics + bytes).slice(-6000) })
+const delay = ms => new Promise(done => setTimeout(done, ms))
+const report = { source: 'canonical practices working tree', cueBoundaries: 0, frames: [], errors: [] }
+let socket
+let id = 0
+const pending = new Map()
+async function cdp(method, params = {}) {
+ const seq = ++id
+ const result = new Promise((done, fail) => pending.set(seq, { done, fail }))
+ socket.send(JSON.stringify({ id: seq, method, params }))
+ return result
+}
+async function evaluate(expression) {
+ const value = await cdp('Runtime.evaluate', { expression, awaitPromise: true, returnByValue: true })
+ if (value.exceptionDetails) throw new Error(JSON.stringify(value.exceptionDetails))
+ return value.result.value
+}
+async function until(expression) {
+ for (let n = 0; n < 100; n += 1) {
+ if (await evaluate(expression)) return
+ await delay(150)
+ }
+ throw new Error(`Timed out: ${expression}`)
+}
+async function frame(name) {
+ const { data } = await cdp('Page.captureScreenshot', { format: 'png', captureBeyondViewport: true })
+ const path = join(out, `${name}.png`)
+ writeFileSync(path, Buffer.from(data, 'base64'))
+ report.frames.push(path.replace(root + '/', ''))
+}
+try {
+ const active = join(profile, 'DevToolsActivePort')
+ for (let n = 0; n < 150 && !existsSync(active); n += 1) await delay(100)
+ assert(existsSync(active), diagnostics)
+ const debugPort = readFileSync(active, 'utf8').split('\n')[0]
+ const tabs = await fetch(`http://127.0.0.1:${debugPort}/json`).then(r => r.json())
+ socket = new WebSocket(tabs[0].webSocketDebuggerUrl)
+ await new Promise(done => socket.addEventListener('open', done, { once: true }))
+ socket.addEventListener('message', event => {
+ const msg = JSON.parse(event.data)
+ if (msg.id) {
+ const task = pending.get(msg.id)
+ pending.delete(msg.id)
+ if (msg.error) task.fail(new Error(JSON.stringify(msg.error)))
+ else task.done(msg.result)
+ } else if (msg.method === 'Runtime.exceptionThrown') report.errors.push(msg.params.exceptionDetails.exception?.description ?? JSON.stringify(msg.params.exceptionDetails))
+ else if (msg.method === 'Runtime.consoleAPICalled' && msg.params.type === 'error') report.errors.push(msg.params.args.map(arg => arg.value ?? arg.description).join(' '))
+ else if (msg.method === 'Log.entryAdded' && msg.params.entry.level === 'error') report.errors.push(msg.params.entry.text + ' ' + msg.params.entry.url)
+ })
+ await cdp('Runtime.enable')
+ await cdp('Log.enable')
+ await cdp('Page.enable')
+ await cdp('Page.navigate', { url: `http://127.0.0.1:${port}/design/astral-projection/three/index.html` })
+ await until('Boolean(window.astral)')
+ for (const [n, item] of items.entries()) {
+ await evaluate(`document.querySelector('#exercise').value = ${n}; document.querySelector('#exercise').dispatchEvent(new Event('change'))`)
+ for (const [i, cue] of item.cues.entries()) {
+ const state = await evaluate(`window.astral.seek(${cue.second})`)
+ assert.equal(state.cue, cue.key)
+ assert.equal(state.caption, text[cue.key])
+ assert.equal(await evaluate('document.querySelector("#caption").textContent'), text[cue.key])
+ if (i) assert.equal((await evaluate(`window.astral.seek(${cue.second - 0.01})`)).index, i - 1)
+ report.cueBoundaries += 1
+ }
+ for (const i of [0, Math.floor(item.cues.length / 2), item.cues.length - 3, item.cues.length - 1]) {
+ const t = item.cues[i].second + 30
+ await evaluate(`window.astral.seek(${t})`)
+ const pixels = await evaluate('window.astral.pixels()')
+ assert(pixels.bright > 300, `Blank ${item.id} at ${t}: ${JSON.stringify(pixels)}`)
+ await frame(`${item.id}-${t}`)
+ }
+ await evaluate(`document.querySelector('#seek').value = ${item.duration}; document.querySelector('#seek').dispatchEvent(new Event('input')); document.querySelector('#play').click()`)
+ await delay(150)
+ assert((await evaluate('window.astral.state()')).time < 2, 'Play restarts completed session')
+ await evaluate('document.querySelector("#play").click()')
+ const paused = await evaluate('window.astral.state().time')
+ await delay(80)
+ assert.equal(await evaluate('window.astral.state().time'), paused)
+ await evaluate('document.querySelector("#restart").click()')
+ assert.equal(await evaluate('window.astral.state().time'), 0)
+ }
+ await cdp('Emulation.setDeviceMetricsOverride', { width: 390, height: 844, deviceScaleFactor: 1, mobile: true })
+ await evaluate('window.dispatchEvent(new Event("resize")); window.astral.select(4); window.astral.seek(1500)')
+ await frame('portrait-rope-1500')
+ assert(await evaluate('document.documentElement.scrollWidth <= innerWidth'), 'Portrait overflow')
+ await cdp('Emulation.clearDeviceMetricsOverride')
+ // The real promo loads Lumi, the monk and Tibetan woman; shader compile
+ // errors are collected from the WebGL console rather than inferred from source.
+ await cdp('Page.navigate', { url: `http://127.0.0.1:${port}/design/promo-film/three/index.html?t=38&width=960&height=540` })
+ await until('Boolean(document.querySelector("#hud")?.textContent)')
+ await frame('promo-shader-review')
+ const errors = report.errors.filter(message => !message.includes('favicon.ico'))
+ assert.deepEqual(errors, [], 'Browser/GLSL errors')
+ report.result = 'PASS'
+ writeFileSync(join(out, 'verification.json'), JSON.stringify(report, null, 2) + '\n')
+ console.log(`PASS: ${report.cueBoundaries} cue boundaries; ${report.frames.length} frames; controls, portrait and promo shaders. Report: build/astral-threejs/verification.json`)
+} catch (error) {
+ console.error(JSON.stringify(report.errors), diagnostics.slice(-1500))
+ throw error
+} finally {
+ if (socket) {
+ try { await cdp('Browser.close') } catch {}
+ socket.close()
+ }
+ browser.kill('SIGTERM')
+ server.close()
+ await delay(600)
+ rmSync(profile, { recursive: true, force: true })
+}
diff --git a/design/promo-film/three/src/character-shaders.js b/design/promo-film/three/src/character-shaders.js
new file mode 100644
index 000000000..992cdb938
--- /dev/null
+++ b/design/promo-film/three/src/character-shaders.js
@@ -0,0 +1,66 @@
+// Shared warm physical / cool awareness palette. No textures or ray marching.
+import { Color, DoubleSide, ShaderMaterial } from 'three'
+
+export const characterLighting = /* glsl */ `
+vec3 characterLight(vec3 base, vec3 n, vec3 eye) {
+ float diffuse = dot(n, normalize(vec3(-0.5, 0.8, 1.0))) * 0.5 + 0.5;
+ float rim = pow(1.0 - abs(dot(n, eye)), 3.0);
+ float wrap = pow(max(0.0, dot(-n, normalize(vec3(-0.5, 0.8, 1.0))) + 0.4), 2.0);
+ return base * (0.55 + 0.55 * diffuse) + vec3(0.20, 0.09, 0.055) * wrap
+ + vec3(0.22, 0.48, 0.55) * rim;
+}
+`
+
+export function bodyMaterial({ astral = false, color = '#bf8973' } = {}) {
+ return new ShaderMaterial({
+ uniforms: {
+ color: { value: new Color(color) },
+ time: { value: 0 },
+ astral: { value: astral ? 1 : 0 },
+ },
+ vertexShader: /* glsl */ `
+ varying vec3 vNormal; varying vec3 vEye; varying vec3 vPosition;
+ void main() {
+ vec4 p = modelViewMatrix * vec4(position, 1.0);
+ vNormal = normalize(normalMatrix * normal);
+ vEye = -p.xyz;
+ vPosition = (modelMatrix * vec4(position, 1.0)).xyz;
+ gl_Position = projectionMatrix * p;
+ }`,
+ fragmentShader: /* glsl */ `
+ uniform vec3 color; uniform float time; uniform float astral;
+ varying vec3 vNormal; varying vec3 vEye; varying vec3 vPosition;
+ ${characterLighting}
+ float hash(vec3 p) { return fract(sin(dot(p, vec3(127.1,311.7,74.7))) * 43758.5453); }
+ float noise(vec3 p) {
+ vec3 i = floor(p), f = fract(p); f = f*f*(3.0-2.0*f);
+ return mix(mix(mix(hash(i),hash(i+vec3(1,0,0)),f.x),
+ mix(hash(i+vec3(0,1,0)),hash(i+vec3(1,1,0)),f.x),f.y),
+ mix(mix(hash(i+vec3(0,0,1)),hash(i+vec3(1,0,1)),f.x),
+ mix(hash(i+vec3(0,1,1)),hash(i+vec3(1,1,1)),f.x),f.y),f.z);
+ }
+ void main() {
+ vec3 n = normalize(vNormal), eye = normalize(vEye);
+ float rim = pow(1.0-abs(dot(n,eye)),2.0);
+ float flow = noise(vPosition*5.0-vec3(0.0,time*0.22,0.0));
+ vec3 physical = characterLight(color,n,eye) * (1.0 + 0.015*sin(time*1.047));
+ vec3 energy = vec3(0.18,0.8,1.0)*(0.65+flow*0.9+rim*1.8);
+ gl_FragColor = vec4(mix(physical,energy,astral),mix(1.0,0.23+rim*0.48+flow*0.15,astral));
+ }`,
+ transparent: astral,
+ depthWrite: !astral,
+ side: DoubleSide,
+ })
+}
+
+// Painted figures have no surface normal map. Alpha gradients provide a
+// shallow relief normal and an edge rim while preserving the painted silhouette.
+export const paintedCharacterLighting = /* glsl */ `
+${characterLighting}
+vec3 lightPaintedCharacter(sampler2D image, vec2 uv, vec2 texel, vec3 rgb, float alpha) {
+ vec2 gradient = vec2(texture2D(image,uv+vec2(texel.x,0)).a-texture2D(image,uv-vec2(texel.x,0)).a,
+ texture2D(image,uv+vec2(0,texel.y)).a-texture2D(image,uv-vec2(0,texel.y)).a);
+ vec3 normal = normalize(vec3(-gradient*2.0, 1.0));
+ return characterLight(rgb,normal,vec3(0,0,1)) + vec3(0.14,0.30,0.34)*length(gradient)*alpha;
+}
+`
diff --git a/design/promo-film/three/src/lumi.js b/design/promo-film/three/src/lumi.js
new file mode 100644
index 000000000..04e9b41dd
--- /dev/null
+++ b/design/promo-film/three/src/lumi.js
@@ -0,0 +1,157 @@
+// Lumi: the eight-frame wing-cycle painting on a plane, her tummy and
+// antenna glows, and a golden trail drawn along the path she flew.
+import {
+ AdditiveBlending, BufferAttribute, BufferGeometry, Color, Group, Mesh, PlaneGeometry, ShaderMaterial,
+} from 'three'
+import { paintedCharacterLighting } from './character-shaders.js'
+import { glow, texture, worldAt, worldPerPixel } from './world.js'
+
+const SHEET = '/design/lumi-promo/lumi-flight-cycle.png'
+const WING_FPS = 16
+// Points in one frame of the sheet, as fractions (x right, y down).
+const TUMMY = [0.52, 0.72]
+const BULBS = [[0.367, 0.298], [0.829, 0.38]]
+
+export async function createLumi() {
+ const sheet = await texture(SHEET)
+ const material = new ShaderMaterial({
+ uniforms: { map: { value: sheet }, frame: { value: 0 }, flip: { value: 0 }, opacity: { value: 1 }, warmth: { value: 1 } },
+ vertexShader: /* glsl */ `varying vec2 vUv; void main() { vUv = uv; gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0); }`,
+ fragmentShader: /* glsl */ `
+uniform sampler2D map; uniform float frame; uniform float flip; uniform float opacity; uniform float warmth;
+varying vec2 vUv;
+${paintedCharacterLighting}
+void main() {
+ vec2 uv = vUv;
+ if (flip > 0.5) uv.x = 1.0 - uv.x;
+ float column = mod(frame, 4.0);
+ float row = floor(frame / 4.0);
+ vec2 cell = vec2((column + uv.x) / 4.0, 1.0 - (row + 1.0 - uv.y) / 2.0);
+ vec4 c = texture2D(map, cell);
+ gl_FragColor = vec4(lightPaintedCharacter(map, cell, vec2(1.0 / 2048.0), c.rgb, c.a) * warmth, c.a * opacity);
+ #include
+}`,
+ transparent: true, depthWrite: false,
+ })
+ const body = new Mesh(new PlaneGeometry(1, 1), material)
+ body.renderOrder = 12
+ body.frustumCulled = false
+ const halo = glow('#ffcf6a', 1)
+ const tummy = glow('#fff1b0', 1)
+ const bulbs = BULBS.map(() => glow('#ffe08a', 1))
+ const group = new Group()
+ group.add(halo, body, tummy, ...bulbs)
+ halo.renderOrder = 11
+
+ let facingLeft = false
+ return {
+ group,
+ // state: { x, y (plate px), f, size (px tall at the plate), t, vx, glow, opacity, face }
+ update({ x, y, f, size, t, vx = 0, light = 1, opacity = 1, face, spark = 0 }) {
+ const position = worldAt(x, y, f)
+ const unit = worldPerPixel(f)
+ const height = size * unit
+ group.position.copy(position)
+ body.scale.set(height, height, 1)
+ if (face !== undefined) {
+ facingLeft = face < 0
+ } else if (Math.abs(vx) > 25) {
+ facingLeft = vx < 0
+ }
+ const flip = facingLeft ? 1 : 0
+ material.uniforms.flip.value = flip
+ material.uniforms.frame.value = Math.floor(t * WING_FPS) % 8
+ material.uniforms.opacity.value = opacity
+ const local = (point) => [((flip ? 1 - point[0] : point[0]) - 0.5) * height, (0.5 - point[1]) * height]
+ const [tx, ty] = local(TUMMY)
+ tummy.position.set(tx, ty, 0.001)
+ tummy.scale.setScalar(height * 0.75)
+ // Before she appears, only her light shows: `spark` keeps it on.
+ const lit = Math.max(opacity, spark)
+ tummy.material.uniforms.intensity.value = 0.55 * light * lit
+ halo.position.set(tx, ty, -0.001)
+ halo.scale.setScalar(height * 2.6)
+ halo.material.uniforms.intensity.value = 0.32 * light * lit
+ BULBS.forEach((point, index) => {
+ const [bx, by] = local(point)
+ bulbs[index].position.set(bx, by, 0.002)
+ bulbs[index].scale.setScalar(height * 0.42)
+ bulbs[index].material.uniforms.intensity.value = 0.7 * light * opacity
+ })
+ },
+ }
+}
+
+// A glowing ribbon along a path: `path(t)` returns { x, y, f } in plate
+// pixels; the ribbon covers [t - length, t], thinning and fading with age.
+export function createTrail({ samples = 120, width = 26, color = '#ffd47a', intensity = 1.2 } = {}) {
+ const geometry = new BufferGeometry()
+ const positions = new Float32Array(samples * 2 * 3)
+ const ages = new Float32Array(samples * 2)
+ const sides = new Float32Array(samples * 2)
+ const index = []
+ for (let i = 0; i < samples - 1; i += 1) {
+ const a = i * 2
+ index.push(a, a + 1, a + 2, a + 1, a + 3, a + 2)
+ }
+ for (let i = 0; i < samples; i += 1) {
+ sides[i * 2] = -1
+ sides[i * 2 + 1] = 1
+ }
+ geometry.setIndex(index)
+ geometry.setAttribute('position', new BufferAttribute(positions, 3))
+ geometry.setAttribute('age', new BufferAttribute(ages, 1))
+ geometry.setAttribute('side', new BufferAttribute(sides, 1))
+ const material = new ShaderMaterial({
+ uniforms: { color: { value: new Color(color) }, intensity: { value: intensity }, time: { value: 0 } },
+ vertexShader: /* glsl */ `
+attribute float age; attribute float side;
+varying float vAge; varying float vSide;
+void main() { vAge = age; vSide = side; gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0); }`,
+ fragmentShader: /* glsl */ `
+uniform vec3 color; uniform float intensity; uniform float time;
+varying float vAge; varying float vSide;
+float hash(float n) { return fract(sin(n) * 43758.5453); }
+void main() {
+ float core = exp(-vSide * vSide * 6.0);
+ float fade = pow(clamp(1.0 - vAge, 0.0, 1.0), 1.6);
+ float sparkle = 0.75 + 0.25 * sin(vAge * 90.0 - time * 9.0);
+ gl_FragColor = vec4(color * core * fade * sparkle * intensity, 1.0);
+}`,
+ blending: AdditiveBlending, transparent: true, depthWrite: false, depthTest: false,
+ })
+ const mesh = new Mesh(geometry, material)
+ mesh.frustumCulled = false
+ mesh.renderOrder = 10
+ return {
+ mesh,
+ update(path, t, length, { start = -Infinity, widthScale = 1, alpha = 1 } = {}) {
+ const from = Math.max(start, t - length)
+ const span = Math.max(1e-3, t - from)
+ const points = []
+ for (let i = 0; i < samples; i += 1) {
+ const time = from + (span * i) / (samples - 1)
+ const p = path(time)
+ points.push(worldAt(p.x, p.y, p.f))
+ }
+ for (let i = 0; i < samples; i += 1) {
+ const p = points[i]
+ const q = points[Math.min(samples - 1, i + 1)]
+ const r = points[Math.max(0, i - 1)]
+ const dx = q.x - r.x
+ const dy = q.y - r.y
+ const len = Math.hypot(dx, dy) || 1
+ const age = 1 - i / (samples - 1)
+ const half = (width * widthScale * worldPerPixel(-p.z / 10)) * (0.25 + 0.75 * (1 - age)) * 0.5
+ const nx = (-dy / len) * half
+ const ny = (dx / len) * half
+ positions.set([p.x + nx, p.y + ny, p.z, p.x - nx, p.y - ny, p.z], i * 6)
+ ages[i * 2] = ages[i * 2 + 1] = Math.min(1, age + (1 - alpha))
+ }
+ geometry.attributes.position.needsUpdate = true
+ geometry.attributes.age.needsUpdate = true
+ material.uniforms.time.value = t
+ mesh.visible = span > 0.05 && alpha > 0.01
+ },
+ }
+}
diff --git a/design/promo-film/three/src/puppets.js b/design/promo-film/three/src/puppets.js
new file mode 100644
index 000000000..04e2bfb39
--- /dev/null
+++ b/design/promo-film/three/src/puppets.js
@@ -0,0 +1,93 @@
+// The painted Tai Chi teachers from design/tai-chi, solved from the real
+// course choreography and drawn into a transparent picture that the
+// courtyard shots place on the plaza.
+import { paintedCharacterLighting } from './character-shaders.js'
+import { HalfFloatType, LinearSRGBColorSpace, Vector3, WebGLRenderTarget } from 'three'
+import { buildCourse, timelineFor } from '/design/tai-chi/src/course.js'
+import { makeRig } from '/design/tai-chi/src/rig.js'
+import { solvePose } from '/design/tai-chi/src/solve.js'
+import { FlatView } from '/design/tai-chi/src/painted/layout.js'
+import { createPaintedFigure, loadCharacter } from '/design/tai-chi/src/painted/figure.js'
+import { premultipliedPlane, worldAt, worldPerPixel } from './world.js'
+
+const CHARACTERS = {
+ monk: '/design/tai-chi/characters/monk/character.json',
+ tibetanWoman: '/design/tai-chi/characters/tibetan-woman/character.json',
+}
+// The picture shows VIEW_HEIGHT metres, twice as wide as tall.
+const VIEW_HEIGHT = 2.3
+const VIEW_CENTER = 0.95
+const PICTURE_ASPECT = 2
+
+let course = null
+
+export async function createPuppet(figure, itemId, { from, yaw = 0, tilt = 0.04 }) {
+ course ??= buildCourse()
+ const item = course.items.get(itemId)
+ const timeline = timelineFor(item).timeline
+ const rig = makeRig(figure)
+ const painted = createPaintedFigure(await loadCharacter(CHARACTERS[figure]), rig)
+ const target = new WebGLRenderTarget(1600, 800, { type: HalfFloatType, colorSpace: LinearSRGBColorSpace, samples: 4 })
+ const plane = premultipliedPlane(target.texture)
+ plane.material.fragmentShader = /* glsl */ `
+ uniform sampler2D map; uniform vec3 tint; uniform float opacity; varying vec2 vUv;
+ ${paintedCharacterLighting}
+ void main() {
+ vec4 c = texture2D(map, vUv);
+ // The render target is premultiplied: shade straight RGB, then
+ // premultiply again so transparent edges cannot acquire a halo.
+ vec3 rgb = c.rgb / max(c.a, 0.0001);
+ rgb = lightPaintedCharacter(map, vUv, vec2(1.0/1600.0,1.0/800.0), rgb, c.a);
+ gl_FragColor = vec4(rgb * tint * c.a, c.a) * opacity;
+ }`
+ // Centre the picture on the pelvis averaged over the shot, so the
+ // figure really travels across the plaza when it steps.
+ const centre = new Vector3()
+ for (let i = 0; i <= 20; i += 1) {
+ const pose = timeline.sample(timeline.start + from + (i / 20) * 9).pose
+ const pelvis = solvePose(pose, rig).joints.pelvis
+ centre.add(new Vector3(pelvis.x, 0, pelvis.z))
+ }
+ centre.multiplyScalar(1 / 21)
+
+ const view = new FlatView()
+ view.set(yaw, tilt, centre)
+ return {
+ plane,
+ painted,
+ // Draws the pose at shot time `t` into the picture.
+ draw(renderer, t) {
+ const sample = timeline.sample(timeline.start + Math.min(timeline.duration, from + Math.max(0, t)))
+ painted.update(solvePose(sample.pose, rig), { yaw, tilt, center: centre, viewHeight: VIEW_HEIGHT, viewCenter: VIEW_CENTER, aspect: PICTURE_ASPECT })
+ const previous = renderer.getRenderTarget()
+ renderer.setRenderTarget(target)
+ renderer.setClearColor(0x000000, 0)
+ renderer.clear()
+ painted.render(renderer)
+ renderer.setRenderTarget(previous)
+ },
+ // Stands the picture with the figure's feet at plate pixel (x, y),
+ // `height` pixels tall for the whole 1.72 m figure, at distance f.
+ place(x, y, height, f) {
+ const pxPerMetre = height / rig.height
+ const pictureHeight = VIEW_HEIGHT * pxPerMetre
+ const bottomPx = y + (VIEW_CENTER - VIEW_HEIGHT / 2) * -pxPerMetre
+ const centrePx = bottomPx - pictureHeight / 2
+ const unit = worldPerPixel(f)
+ plane.position.copy(worldAt(x, centrePx, f))
+ plane.scale.set(pictureHeight * PICTURE_ASPECT * unit, pictureHeight * unit, 1)
+ this.layout = { x, y, height, f, pxPerMetre }
+ },
+ // Where a joint is on the plate at shot time `t`, in pixels (Lumi
+ // follows a hand).
+ jointPixel(name, t) {
+ if (!this.layout) {
+ return null
+ }
+ const sample = timeline.sample(timeline.start + Math.min(timeline.duration, from + Math.max(0, t)))
+ const point = view.point(solvePose(sample.pose, rig).joints[name])
+ const { x, y, pxPerMetre } = this.layout
+ return { x: x + point.x * pxPerMetre, y: y - point.y * pxPerMetre }
+ },
+ }
+}
diff --git a/plans/2026-11-17-astral-projection.md b/plans/2026-11-17-astral-projection.md
new file mode 100644
index 000000000..3e67b281a
--- /dev/null
+++ b/plans/2026-11-17-astral-projection.md
@@ -0,0 +1,108 @@
+# Open astral projection work — 2026-11-17
+
+## Review and integration still open
+
+- Owner review of all six Three.js studies and shared character shader looks.
+ Preview implementation is deliberately separate from app integration. After
+ review, scope the native/Kryon equivalent; this page is not installed in Breeze.
+- Reconcile the historical status notes with the already committed selection:
+ `017d3565` contains the six-exercise work; `ca99ca92` updates the native
+ implementation. Both precede the freshly observed remote Breeze master
+ `a3a37e38`. Notes claiming “no feature commit/push” are stale for Breeze code.
+ No review receipt establishes that the owner saw those screens.
+- Practices master and fresh remote master both equal `b68738d0`. The six
+ catalogue/session JSON files remain untracked, with localized text/audio
+ changes outside this task. They are not in the pushed practices package.
+ Complete and validate that lane before updating Breeze's locked practices pin
+ (currently `893e5b6f`). This task changes none of those files or pins.
+- Final native/package laws, size/inventory, exact media delivery and installed
+ download/desktop launch verification remain open. Historical progress notes
+ record successful private chooser tests at desktop/portrait sizes (guides,
+ cues, countdown, pause/resume, restart, switching, completion/history) and
+ native download-flow tests, but distinguish those from actual installed
+ downloads. Repeat on the final integrated source/media revision; no fresh
+ native GUI claim is made by this standalone web change.
+
+## Narration still open
+
+All ten locale catalogues contain all 88 new cues. Current local Bruce files
+and receipt rows agree at the counts below; SHA-256 of each existing audio file
+matches its receipt. Counts do **not** establish current synthesis-profile/text
+provenance, listening quality, full decode or coverage of other voice choices.
+A fresh strict narration validation and voice/listening review remain required.
+
+| Locale | Female provider recorded | Existing / 88 | Missing |
+|---|---|---:|---:|
+| cs | Chatterbox Czech | 6 | 82 |
+| de | Ming | 86 | 2 |
+| en | Ming | 86 | 2 |
+| es | Ming | 78 | 10 |
+| fr | Ming | 37 | 51 |
+| ja | Ming | 5 | 83 |
+| ko | Ming | 6 | 82 |
+| pt | Chatterbox Portuguese | 88 | 0 |
+| ru | F5 Russian | 10 | 78 |
+| zh | Ming | 5 | 83 |
+
+- Finish the missing 473 of 880 new female clips through the owning narration
+ task. Portuguese has full inventory, but still needs final provenance and
+ integrated listening verification. Preserve all existing recordings.
+- The interface specifies these female routes only. Any other selectable voice
+ must be audited against actual package coverage; no complete alternate voice
+ inventory or listening evidence was established here. Legacy English's 20
+ old cues are separate and do not fill the new exercise keys.
+- The broader progress notes' 4,960-clip target includes other practices; their
+ unresolved narration items are outside this animation task.
+
+## Preview verification and remaining limits
+
+- Private software Chromium exercises the page; real phone GPU performance and
+ visual acceptance remain open. Width is capped at 960 and pixel ratio at 1.
+- English captions are a reproducible snapshot of the current practices working
+ tree, including uncommitted source data. Source JSON is not claimed pushed.
+ Refresh the snapshot after the practices owner finalizes cue/text changes.
+- Open locally with `node design/promo-film/three/tools/serve.mjs`, then visit
+ `http://127.0.0.1:8772/design/astral-projection/three/index.html`.
+- Local verification command:
+ `build-queue -- node design/astral-projection/three/tools/verify.mjs`.
+ Result: PASS, 88 cue boundaries (including immediately before each transition),
+ exact canonical captions, six pickers/seek paths, play/pause/restart, nonblank
+ canvas pixels at four cue times per exercise, portrait layout and the real
+ promo scene at 38 seconds (Lumi, monk and Tibetan woman). No JavaScript/GLSL
+ errors; the unused favicon 404 is excluded. A stale FlatView import was fixed
+ in the shader-touched puppet module to enable the actual promo render.
+ Report: `build/astral-threejs/verification.json`.
+- The existing promo stack and artwork are ignored by Git. This scoped commit
+ includes the three shader-touched source files only; it does not publish the
+ pre-existing film assets, server or node_modules. Another machine needs that
+ existing local promo setup (and Three.js 0.169.0) to run this preview/test.
+ Packaging the entire film stack is outside this task.
+
+Private-display frames (local artifacts, not committed):
+
+- `build/astral-threejs/bruce_foundation_touch-30.png`
+- `build/astral-threejs/bruce_foundation_touch-630.png`
+- `build/astral-threejs/bruce_foundation_touch-870.png`
+- `build/astral-threejs/bruce_foundation_touch-1110.png`
+- `build/astral-threejs/bruce_full_body_current-30.png`
+- `build/astral-threejs/bruce_full_body_current-750.png`
+- `build/astral-threejs/bruce_full_body_current-1230.png`
+- `build/astral-threejs/bruce_full_body_current-1470.png`
+- `build/astral-threejs/bruce_elevator_trance-30.png`
+- `build/astral-threejs/bruce_elevator_trance-870.png`
+- `build/astral-threejs/bruce_elevator_trance-1470.png`
+- `build/astral-threejs/bruce_elevator_trance-1710.png`
+- `build/astral-threejs/bruce_spin_loosening-30.png`
+- `build/astral-threejs/bruce_spin_loosening-870.png`
+- `build/astral-threejs/bruce_spin_loosening-1470.png`
+- `build/astral-threejs/bruce_spin_loosening-1710.png`
+- `build/astral-threejs/bruce_rope_exit-30.png`
+- `build/astral-threejs/bruce_rope_exit-1230.png`
+- `build/astral-threejs/bruce_rope_exit-2070.png`
+- `build/astral-threejs/bruce_rope_exit-2310.png`
+- `build/astral-threejs/bruce_roll_out_exit-30.png`
+- `build/astral-threejs/bruce_roll_out_exit-870.png`
+- `build/astral-threejs/bruce_roll_out_exit-1470.png`
+- `build/astral-threejs/bruce_roll_out_exit-1710.png`
+- `build/astral-threejs/portrait-rope-1500.png`
+- `build/astral-threejs/promo-shader-review.png`