@pascal-app/editor 1.0.0-beta.5 → 1.0.1

package/src/lib/send-to-app.test.ts

@@ -0,0 +1,108 @@
+import { describe, expect, test } from 'bun:test'
+import { LocalAppError, probeLocalApp, sendGlbToLocalApp, waitForLocalImport } from './send-to-app'
+
+type Handler = (url: string, init?: RequestInit) => Response | Promise<Response>
+
+function fakeFetch(handler: Handler): typeof fetch {
+  return ((input: RequestInfo | URL, init?: RequestInit) =>
+    Promise.resolve(handler(String(input), init))) as typeof fetch
+}
+
+const json = (body: unknown, status = 200) =>
+  new Response(JSON.stringify(body), { status, headers: { 'Content-Type': 'application/json' } })
+
+describe('probeLocalApp', () => {
+  test('reports unreachable when nothing answers on any port', async () => {
+    const tried: string[] = []
+    const probe = await probeLocalApp(
+      fakeFetch((url) => {
+        tried.push(url)
+        throw new TypeError('Failed to fetch')
+      }),
+      27412,
+      3,
+    )
+    expect(probe).toEqual({ status: 'unreachable' })
+    expect(tried).toEqual([
+      'http://127.0.0.1:27412/pascal/health',
+      'http://127.0.0.1:27413/pascal/health',
+      'http://127.0.0.1:27414/pascal/health',
+    ])
+  })
+
+  test('finds the app on a fallback port and tells whether it allows this origin', async () => {
+    const health = { app: 'blender', version: '5.2.1', addon: '0.1.0', port: 27413, allowed: false }
+    const probe = await probeLocalApp(
+      fakeFetch((url) => {
+        if (url.startsWith('http://127.0.0.1:27413/')) return json(health)
+        throw new TypeError('Failed to fetch')
+      }),
+    )
+    expect(probe).toEqual({ status: 'refused', base: 'http://127.0.0.1:27413', health })
+  })
+})
+
+describe('sendGlbToLocalApp', () => {
+  test('posts the GLB with percent-encoded project headers', async () => {
+    let seen: RequestInit | undefined
+    const status = await sendGlbToLocalApp(
+      'http://127.0.0.1:27412',
+      new Blob([new Uint8Array([1, 2, 3])]),
+      { name: 'Maison été', projectId: 'project_1' },
+      fakeFetch((_url, init) => {
+        seen = init
+        return json({ id: 'abc', state: 'queued' }, 202)
+      }),
+    )
+    expect(status).toEqual({ id: 'abc', state: 'queued' })
+    expect(seen?.method).toBe('POST')
+    expect(seen?.headers).toEqual({
+      'Content-Type': 'model/gltf-binary',
+      'X-Pascal-Project-Name': 'Maison%20%C3%A9t%C3%A9',
+      'X-Pascal-Project-Id': 'project_1',
+    })
+  })
+
+  test('maps a 403 to a refused error', async () => {
+    await expect(
+      sendGlbToLocalApp(
+        'http://127.0.0.1:27412',
+        new Blob([]),
+        {},
+        fakeFetch(() => json({ error: 'origin_not_allowed' }, 403)),
+      ),
+    ).rejects.toMatchObject({ name: 'LocalAppError', reason: 'refused' })
+  })
+})
+
+describe('waitForLocalImport', () => {
+  test('polls until the import is done', async () => {
+    let calls = 0
+    const status = await waitForLocalImport(
+      'http://127.0.0.1:27412',
+      'abc',
+      fakeFetch(() => {
+        calls += 1
+        return json(
+          calls < 3
+            ? { id: 'abc', state: 'queued' }
+            : { id: 'abc', state: 'done', summary: 'Imported' },
+        )
+      }),
+      { intervalMs: 1 },
+    )
+    expect(status.state).toBe('done')
+    expect(calls).toBe(3)
+  })
+
+  test('surfaces a failed import', async () => {
+    const error = await waitForLocalImport(
+      'http://127.0.0.1:27412',
+      'abc',
+      fakeFetch(() => json({ id: 'abc', state: 'failed', error: 'boom' })),
+      { intervalMs: 1 },
+    ).catch((e: unknown) => e)
+    expect(error).toBeInstanceOf(LocalAppError)
+    expect((error as LocalAppError).reason).toBe('failed')
+  })
+})

package/src/lib/send-to-app.ts

@@ -0,0 +1,121 @@
+/**
+ * Hand a scene to a desktop app listening on loopback (the Pascal Blender add-on
+ * today). The app answers `GET /pascal/health`, accepts a GLB on
+ * `POST /pascal/import`, and reports the import on `GET /pascal/import/<id>`.
+ * Protocol reference: https://github.com/pascalorg/blender-addon#send-to-blender-from-the-editor
+ */
+
+export const LOCAL_APP_PORT = 27412
+export const LOCAL_APP_PORT_RANGE = 5
+const PROBE_TIMEOUT_MS = 1000
+
+export type LocalAppHealth = {
+  app: string
+  version: string
+  addon: string
+  port: number
+  allowed: boolean
+}
+
+export type LocalAppProbe =
+  | { status: 'listening'; base: string; health: LocalAppHealth }
+  | { status: 'refused'; base: string; health: LocalAppHealth }
+  | { status: 'unreachable' }
+
+export type LocalImportStatus = {
+  id: string
+  state: 'queued' | 'done' | 'failed'
+  summary?: string
+  error?: string
+}
+
+export class LocalAppError extends Error {
+  constructor(
+    readonly reason: 'refused' | 'rejected' | 'failed' | 'timeout',
+    message: string,
+  ) {
+    super(message)
+    this.name = 'LocalAppError'
+  }
+}
+
+type FetchLike = typeof fetch
+
+function isHealth(value: unknown): value is LocalAppHealth {
+  const health = value as Partial<LocalAppHealth> | null
+  return Boolean(health && typeof health.app === 'string' && typeof health.allowed === 'boolean')
+}
+
+/** Try the app's port and a few after it, one second each. */
+export async function probeLocalApp(
+  fetchImpl: FetchLike = fetch,
+  port = LOCAL_APP_PORT,
+  range = LOCAL_APP_PORT_RANGE,
+): Promise<LocalAppProbe> {
+  for (let candidate = port; candidate < port + range; candidate++) {
+    const base = `http://127.0.0.1:${candidate}`
+    try {
+      const response = await fetchImpl(`${base}/pascal/health`, {
+        cache: 'no-store',
+        signal: AbortSignal.timeout(PROBE_TIMEOUT_MS),
+      })
+      if (!response.ok) continue
+      const health: unknown = await response.json()
+      if (!isHealth(health)) continue
+      return { status: health.allowed ? 'listening' : 'refused', base, health }
+    } catch {
+      // Nothing listening there; try the next port.
+    }
+  }
+  return { status: 'unreachable' }
+}
+
+export type SendSceneMeta = {
+  name?: string
+  projectId?: string
+  version?: string
+}
+
+/** POST the GLB; resolves with the queued import id. */
+export async function sendGlbToLocalApp(
+  base: string,
+  blob: Blob,
+  meta: SendSceneMeta = {},
+  fetchImpl: FetchLike = fetch,
+): Promise<LocalImportStatus> {
+  const headers: Record<string, string> = { 'Content-Type': 'model/gltf-binary' }
+  // Header values are Latin-1; the listener percent-decodes these.
+  if (meta.name) headers['X-Pascal-Project-Name'] = encodeURIComponent(meta.name)
+  if (meta.projectId) headers['X-Pascal-Project-Id'] = meta.projectId
+  if (meta.version) headers['X-Pascal-Version'] = meta.version
+  const response = await fetchImpl(`${base}/pascal/import`, { method: 'POST', headers, body: blob })
+  if (response.status === 403) {
+    throw new LocalAppError('refused', 'The app has not allowed this site to send scenes.')
+  }
+  if (!response.ok) {
+    throw new LocalAppError('rejected', `The app rejected the scene (HTTP ${response.status}).`)
+  }
+  return (await response.json()) as LocalImportStatus
+}
+
+/** Poll until the app has imported (or failed to import) the queued scene. */
+export async function waitForLocalImport(
+  base: string,
+  id: string,
+  fetchImpl: FetchLike = fetch,
+  { timeoutMs = 120_000, intervalMs = 500 } = {},
+): Promise<LocalImportStatus> {
+  const deadline = Date.now() + timeoutMs
+  while (Date.now() < deadline) {
+    const response = await fetchImpl(`${base}/pascal/import/${id}`, { cache: 'no-store' })
+    if (response.ok) {
+      const status = (await response.json()) as LocalImportStatus
+      if (status.state === 'done') return status
+      if (status.state === 'failed') {
+        throw new LocalAppError('failed', status.error ?? 'The app could not import the scene.')
+      }
+    }
+    await new Promise((resolve) => setTimeout(resolve, intervalMs))
+  }
+  throw new LocalAppError('timeout', 'The app did not finish importing in time.')
+}

package/src/lib/sfx/movement-tick.ts

@@ -1,3 +1,5 @@
+import { sfxEmitter } from '../sfx-bus'
+
 const DEFAULT_FREE_MOVEMENT_SFX_STEP_M = 0.1
 
 type MovementSfxStepKeyArgs = {
@@ -16,3 +18,38 @@ export function movementSfxStepKey({
   const step = gridSnapActive && gridStep > 0 ? gridStep : freeStep
   return coords.map((coord) => Math.round(coord / step)).join(',')
 }
+
+export function createMovementSfxTick() {
+  let previousKey: string | null = null
+  let pending: (() => void) | null = null
+  let timer: ReturnType<typeof setTimeout> | undefined
+  const tick = (args: MovementSfxStepKeyArgs, emitInitialStep = false) => {
+    const nextKey = movementSfxStepKey(args)
+    if (nextKey !== previousKey && (previousKey !== null || emitInitialStep)) {
+      sfxEmitter.emit('sfx:grid-snap')
+    }
+    previousKey = nextKey
+  }
+  const cancel = () => {
+    clearTimeout(timer)
+    timer = undefined
+    pending = null
+  }
+  const flush = () => {
+    const apply = pending
+    cancel()
+    apply?.()
+  }
+  return {
+    tick,
+    schedule(args: MovementSfxStepKeyArgs, shouldPlay: () => boolean, emitInitialStep = false) {
+      pending = () => {
+        if (shouldPlay()) tick(args, emitInitialStep)
+      }
+      // Wait for R3F host dispatch after the native grid listener, without delaying the move.
+      if (timer === undefined) timer = setTimeout(flush, 0)
+    },
+    flush,
+    cancel,
+  }
+}

package/src/lib/sfx-bus.ts

@@ -27,6 +27,7 @@ type SFXEvents = {
   'sfx:menu-hover': undefined
   'sfx:menu-click': undefined
   'sfx:paint-apply': undefined
+  'sfx:success': undefined
   'sfx:terrain-sculpt-start': TerrainVerb
   'sfx:terrain-sculpt-stop': undefined
 }
@@ -56,6 +57,7 @@ const handleSnapshotCapture = () => playSFX('snapshotCapture')
 const handleMenuHover = () => playSFX('menuHover')
 const handleMenuClick = () => playSFX('menuClick')
 const handlePaintApply = () => playSFX('paintApply')
+const handleSuccess = () => playSFX('success')
 const TERRAIN_LOOP_BY_VERB = {
   raise: 'terrainRaise',
   lower: 'terrainLower',
@@ -86,6 +88,7 @@ export function initSFXBus() {
   sfxEmitter.on('sfx:menu-hover', handleMenuHover)
   sfxEmitter.on('sfx:menu-click', handleMenuClick)
   sfxEmitter.on('sfx:paint-apply', handlePaintApply)
+  sfxEmitter.on('sfx:success', handleSuccess)
   sfxEmitter.on('sfx:terrain-sculpt-start', handleTerrainSculptStart)
   sfxEmitter.on('sfx:terrain-sculpt-stop', handleTerrainSculptStop)
   unsubscribeAudio = useAudio.subscribe(updateSFXVolumes)
@@ -106,6 +109,7 @@ export function disposeSFXBus() {
     sfxEmitter.off('sfx:menu-hover', handleMenuHover)
     sfxEmitter.off('sfx:menu-click', handleMenuClick)
     sfxEmitter.off('sfx:paint-apply', handlePaintApply)
+    sfxEmitter.off('sfx:success', handleSuccess)
     sfxEmitter.off('sfx:terrain-sculpt-start', handleTerrainSculptStart)
     sfxEmitter.off('sfx:terrain-sculpt-stop', handleTerrainSculptStop)
     unsubscribeAudio?.()

package/src/lib/sfx-player.ts

@@ -112,6 +112,14 @@ export const SFX: Record<string, SFXConfig> = {
     volumeRange: [0.85, 1.0],
     minIntervalMs: 60,
   },
+  // A three-second jingle for finishing something, not a click cue. No pitch or
+  // volume jitter — a fanfare that lands a semitone off reads as broken rather
+  // than as varied — and a gap longer than the sound itself, so two milestones
+  // that land together play once instead of phasing over each other.
+  success: {
+    src: '/audios/sfx/success.mp3',
+    minIntervalMs: 3_000,
+  },
 } as const
 
 export type SFXName = keyof typeof SFX

package/src/lib/snapping-mode.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'bun:test'
-import { ROTATE_HANDLE_DRAG_LABEL } from './contextual-help'
+import { GROUP_MOVE_DRAG_LABEL, ROTATE_HANDLE_DRAG_LABEL } from './contextual-help'
 import {
   cycleSnappingModeIn,
   DEFAULT_SNAPPING_MODE,
@@ -49,12 +49,24 @@ describe('resolveSnapFlags', () => {
 })
 
 describe('per-context snapping', () => {
-  it('items default to grid with no angle lock', () => {
-    expect(defaultSnappingModeFor('item')).toBe('grid')
+  it('items default to magnetic alignment with no angle lock', () => {
+    expect(defaultSnappingModeFor('item')).toBe('lines')
     expect(snappingModesFor('item')).toEqual(['lines', 'grid', 'off'])
     expect(snappingModesFor('item')).not.toContain('angles')
   })
 
+  it('group moves use the magnetic item context by default', () => {
+    const context = snapContextOf({
+      scope: { kind: 'handle-drag', handle: GROUP_MOVE_DRAG_LABEL },
+      mode: 'select',
+      tool: null,
+      profileOf: () => undefined,
+    })
+
+    expect(context).toBe('item')
+    expect(resolveSnapFlags(defaultSnappingModeFor(context!)).magnetic).toBe(true)
+  })
+
   it('walls default to grid and expose the angle lock; polygons do NOT', () => {
     expect(defaultSnappingModeFor('wall')).toBe('grid')
     expect(defaultSnappingModeFor('polygon')).toBe('grid')
@@ -83,10 +95,17 @@ describe('snapContextOf (profile-driven, node-declared)', () => {
     ceiling: 'structural',
     roof: 'structural',
     zone: 'structural',
+    block: 'structural',
   }
   const profileOf = (t: string) => declared[t]
   const profileOfNode = (id: string) =>
-    id === 'cabinet-module_1' ? declared.item : id === 'wall_1' ? declared.wall : undefined
+    id === 'cabinet-module_1'
+      ? declared.item
+      : id === 'wall_1'
+        ? declared.wall
+        : id === 'block_1'
+          ? declared['block']
+          : undefined
   const ctx = (
     scope: {
       kind: string
@@ -95,6 +114,7 @@ describe('snapContextOf (profile-driven, node-declared)', () => {
       nodeId?: string
       tool?: string
       handle?: string
+      operator?: string
     },
     mode = 'select',
     tool: string | null = null,
@@ -115,6 +135,14 @@ describe('snapContextOf (profile-driven, node-declared)', () => {
     ).toBeNull()
   })
 
+  it('gives mesh rotation the angle context and other edit operations polygon snapping', () => {
+    expect(ctx({ kind: 'mesh-editing', nodeId: 'block_1' })).toBe('polygon')
+    expect(ctx({ kind: 'mesh-editing', nodeId: 'block_1', operator: 'translate' })).toBe('polygon')
+    expect(ctx({ kind: 'mesh-editing', nodeId: 'block_1', operator: 'scale' })).toBe('polygon')
+    expect(ctx({ kind: 'mesh-editing', nodeId: 'block_1', operator: 'loop-cut' })).toBe('polygon')
+    expect(ctx({ kind: 'mesh-editing', nodeId: 'block_1', operator: 'rotate' })).toBe('wall')
+  })
+
   it('endpoint reshape is angle-bearing (wall); curve + polygon vertex edits are not', () => {
     expect(ctx({ kind: 'reshaping', reshape: 'endpoint' })).toBe('wall')
     expect(ctx({ kind: 'reshaping', reshape: 'curve' })).toBe('polygon')

package/src/lib/snapping-mode.ts

@@ -4,10 +4,9 @@ import { GROUP_MOVE_DRAG_LABEL, ROTATE_HANDLE_DRAG_LABEL } from './contextual-he
 /**
  * Snapping mode is a single global, user-cyclable control that maps onto the
  * two pre-existing snap knobs (`gridSnapStep` grid snap + `magneticSnap`).
- * The default `'grid'` resolves to the exact pair the editor shipped with
- * before this control existed (grid on, magnetic on), so the default path is
- * behaviourally unchanged — only when a user opts into `'lines'` or `'off'`
- * does any snap math get suppressed.
+ * Each context chooses its own default. Item movement defaults to magnetic
+ * alignment so a picked-up group catches neighboring geometry; grid and off
+ * remain explicit alternatives in the contextual chip.
  */
 export type SnappingMode = 'grid' | 'lines' | 'angles' | 'off'
 
@@ -82,9 +81,9 @@ type SnapModeSet = { modes: SnappingMode[]; default: SnappingMode }
 const SNAP_PROFILES: Record<SnapContext, SnapModeSet> = {
   // Wall / fence drafting + endpoint reshape: direction matters → angle lock.
   wall: { modes: ['grid', 'lines', 'angles', 'off'], default: 'grid' },
-  // Item placement / move: grid by default; lines = magnetic alignment only (no
-  // grid lattice), no angle lock (meaningless for a footprint).
-  item: { modes: ['lines', 'grid', 'off'], default: 'grid' },
+  // Item placement / move: magnetic alignment by default; grid is an explicit
+  // alternative, and angle lock is meaningless for a footprint.
+  item: { modes: ['lines', 'grid', 'off'], default: 'lines' },
   // Structural / surface, no direction to set: slab / ceiling / roof draft+move,
   // whole wall/fence translate, curve reshape, polygon boundary edit. Grid by
   // default, NO angle lock.
@@ -148,6 +147,7 @@ export function snapContextOf(args: {
     nodeId?: string
     tool?: string
     handle?: string
+    operator?: string
   }
   mode: string
   tool: string | null
@@ -166,6 +166,10 @@ export function snapContextOf(args: {
     return 'item'
   }
   switch (scope.kind) {
+    case 'mesh-editing':
+      return scope.nodeId
+        ? contextForProfile(profileOfNode?.(scope.nodeId), scope.operator === 'rotate')
+        : null
     case 'handle-drag':
       if (scope.handle === ROTATE_HANDLE_DRAG_LABEL) return null
       return scope.nodeId ? contextForProfile(profileOfNode?.(scope.nodeId), false) : null

package/src/lib/surface-attachment.ts

@@ -0,0 +1,77 @@
+import { type AnyNode, type AnyNodeId, useScene } from '@pascal-app/core'
+import { evaluateRecipe, isProceduralItem } from '@pascal-app/core/procedural-items'
+import { Euler, Quaternion, Vector3 } from 'three'
+
+type Pose = { position: [number, number, number]; rotation: [number, number, number] }
+
+export function surfaceAttachmentId(node: Pick<AnyNode, 'id' | 'parentId'>): string | null {
+  const parent = node.parentId ? useScene.getState().nodes[node.parentId as AnyNodeId] : undefined
+  return isProceduralItem(parent) ? (parent.attachments[node.id] ?? null) : null
+}
+
+export function surfaceAttachmentUpdates(
+  id: AnyNodeId,
+  parentId: string | null | undefined,
+  surfaceId: string | null,
+) {
+  const nodes = useScene.getState().nodes
+  const updates: { id: AnyNodeId; data: Partial<AnyNode> }[] = []
+  for (const hostId of new Set([nodes[id]?.parentId, parentId])) {
+    const host = hostId ? nodes[hostId as AnyNodeId] : undefined
+    if (!isProceduralItem(host)) continue
+    const nextId = host.id === parentId ? surfaceId : null
+    if ((host.attachments[id] ?? null) === nextId) continue
+    const attachments = { ...host.attachments }
+    if (nextId === null) delete attachments[id]
+    else attachments[id] = nextId
+    updates.push({ id: host.id, data: { attachments } })
+  }
+  return updates
+}
+
+export function updateSurfaceNode(
+  id: AnyNodeId,
+  data: Partial<AnyNode>,
+  surfaceId?: string | null,
+) {
+  const node = useScene.getState().nodes[id]
+  const parentId = data.parentId === undefined ? node?.parentId : data.parentId
+  const selected =
+    surfaceId === undefined && node && node.parentId === parentId
+      ? surfaceAttachmentId(node)
+      : (surfaceId ?? null)
+  useScene
+    .getState()
+    .updateNodes([{ id, data }, ...surfaceAttachmentUpdates(id, parentId, selected)])
+}
+
+export function surfaceFramePose(
+  parentId: string | null | undefined,
+  surfaceId: string | null,
+  pose: Pose,
+  toStorage: boolean,
+): Pose {
+  const host = parentId ? useScene.getState().nodes[parentId as AnyNodeId] : undefined
+  if (!isProceduralItem(host) || surfaceId === null)
+    return { position: pose.position, rotation: pose.rotation }
+  const surface = evaluateRecipe(host.recipe, host.parameters).surfaces.find(
+    (s) => s.id === surfaceId,
+  )
+  if (!surface) throw new Error('Missing attachment surface')
+  const q = new Quaternion().setFromEuler(new Euler(...surface.rotation))
+  const position = new Vector3(...pose.position)
+  if (toStorage) position.sub(new Vector3(...surface.position)).applyQuaternion(q.clone().invert())
+  else position.applyQuaternion(q).add(new Vector3(...surface.position))
+  if (!surface.rotation[0] && !surface.rotation[2] && !pose.rotation[0] && !pose.rotation[2]) {
+    return {
+      position: position.toArray(),
+      rotation: [0, pose.rotation[1] + (toStorage ? -1 : 1) * surface.rotation[1], 0],
+    }
+  }
+  const rotation = new Euler().setFromQuaternion(
+    new Quaternion()
+      .setFromEuler(new Euler(...pose.rotation))
+      .premultiply(toStorage ? q.invert() : q),
+  )
+  return { position: position.toArray(), rotation: [rotation.x, rotation.y, rotation.z] }
+}