@playcraft/cli 0.0.43 → 0.0.46

package/project-templates/phaser/skills/playable-record/scripts/lib/record-audio-bridge.js

@@ -0,0 +1,141 @@
+function pickAvMimeType() {
+  const candidates = [
+    'video/webm;codecs=vp8',
+    'video/webm;codecs=vp9',
+    'video/webm'
+  ];
+  return candidates.find((mime) => MediaRecorder.isTypeSupported(mime)) || 'video/webm';
+}
+
+function resolveCaptureSurface(fps) {
+  const playable = window.__playable;
+  const game = window.__game;
+
+  let canvas = null;
+  let targetFps = fps;
+
+  if (playable && typeof playable.getCanvas === 'function') {
+    canvas = playable.getCanvas();
+  }
+  if (!canvas && game?.canvas) {
+    canvas = game.canvas;
+  }
+  if (playable && typeof playable.getCaptureFps === 'function') {
+    targetFps = playable.getCaptureFps() || targetFps;
+  } else if (game?.loop) {
+    game.loop.targetFps = targetFps;
+    game.loop.forceSetTimeOut = false;
+  }
+
+  return { canvas, targetFps, hasGame: !!game, hasPlayable: !!playable };
+}
+
+function startAvCapture(fps) {
+  try {
+    const { canvas, targetFps, hasGame, hasPlayable } = resolveCaptureSurface(fps);
+
+    window.__avCaptureDebug = {
+      hasGame,
+      hasPlayable,
+      hasCanvas: !!canvas,
+      canvasType: canvas?.constructor?.name,
+      captureStreamType: typeof canvas?.captureStream,
+      mimeType: null,
+      recorderState: null,
+      error: null,
+      chunks: 0
+    };
+
+    if (!canvas) {
+      throw new Error('Capture canvas not ready — implement window.__playable.getCanvas() or expose Phaser game.canvas');
+    }
+
+    const videoStream = canvas.captureStream(targetFps);
+    const audioCtx = new (window.AudioContext || window.webkitAudioContext)({ sampleRate: 48000 });
+    const dest = audioCtx.createMediaStreamDestination();
+    const silence = audioCtx.createOscillator();
+    silence.frequency.value = 0;
+    const gain = audioCtx.createGain();
+    gain.gain.value = 0.0001;
+    silence.connect(gain);
+    gain.connect(dest);
+    silence.start();
+    const combined = new MediaStream([
+      ...videoStream.getVideoTracks(),
+      ...dest.stream.getAudioTracks()
+    ]);
+    const mimeType = pickAvMimeType();
+    window.__avCaptureDebug.mimeType = mimeType;
+
+    const recorder = new MediaRecorder(combined, {
+      mimeType,
+      videoBitsPerSecond: 8_000_000
+    });
+
+    window.__recordAv = {
+      chunks: [],
+      recorder,
+      videoStream: combined,
+      audioCtx,
+      silence,
+      mimeType,
+      fps
+    };
+
+    recorder.ondataavailable = (e) => {
+      if (e.data.size) window.__recordAv.chunks.push(e.data);
+    };
+    recorder.start(100);
+    window.__avCaptureDebug.recorderState = recorder.state;
+  } catch (err) {
+    if (window.__avCaptureDebug) window.__avCaptureDebug.error = err.message;
+    else window.__avCaptureDebug = { error: err.message };
+    throw err;
+  }
+}
+
+function stopAvCapture() {
+  const state = window.__recordAv;
+  if (!state?.recorder) {
+    throw new Error('AV capture was not started');
+  }
+
+  const { recorder, chunks, videoStream } = state;
+
+  if (window.__avCaptureDebug) {
+    window.__avCaptureDebug.chunks = chunks.length;
+    window.__avCaptureDebug.totalBytes = chunks.reduce((a, c) => a + c.size, 0);
+  }
+
+  return new Promise((resolve, reject) => {
+    recorder.onstop = async () => {
+      try {
+        const blob = new Blob(chunks, { type: state.mimeType || 'video/webm' });
+        videoStream.getTracks().forEach((track) => track.stop());
+        if (state.audioCtx) { try { state.audioCtx.close(); } catch {} }
+        if (state.silence) { try { state.silence.stop(); } catch {} }
+        window.__recordAv = null;
+        const buf = await blob.arrayBuffer();
+        resolve(Array.from(new Uint8Array(buf)));
+      } catch (err) {
+        reject(err);
+      }
+    };
+    recorder.onerror = () => reject(new Error('MediaRecorder failed'));
+    if (recorder.state === 'inactive') {
+      reject(new Error('MediaRecorder already stopped'));
+      return;
+    }
+    recorder.stop();
+  });
+}
+
+/** @deprecated use startAvCapture */
+function startAudioCapture() {
+  startAvCapture(25);
+}
+
+/** @deprecated use stopAvCapture */
+function stopAudioCapture() {
+  return stopAvCapture();
+}

package/project-templates/phaser/skills/playable-record/scripts/lib/slice-structure-verify.mjs

@@ -0,0 +1,199 @@
+/**
+ * slice-axis-v1 — structure-only slice verifiers for non-runtime roles (Artist / TA).
+ * Does not judge asset quality or run bulk production checks.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { getActiveSlice, readState } from '../../../_shared/scripts/state-store.mjs';
+
+const ARTIST_SCOPE = new Set(['style', 'mc', 'asr']);
+const TA_STATUS = new Set(['ready', 'blocked']);
+
+/** @param {import('../../../_shared/scripts/state-store.mjs').SliceRecord} slice @param {string} key */
+export function routeFor(slice, key) {
+  const fb = slice?.fallbackRoute?.[key] || null;
+  if (fb) return { failKey: key, routeTo: fb.routeTo, reason: fb.reason };
+  return { failKey: key, routeTo: slice?.role === 'technical-artist' ? 'technical-artist' : 'artist', reason: key };
+}
+
+/**
+ * @param {string} root
+ * @param {'artist'|'technical-artist'} expectedRole
+ */
+function loadManifest(root, expectedRole) {
+  const slice = getActiveSlice(readState(root));
+  if (!slice) {
+    return {
+      ok: false,
+      sliceId: null,
+      problems: ['no active slice in docs/project-state.json (sliceState.activeSliceId is none)'],
+      route: null,
+    };
+  }
+  if (slice.role !== expectedRole) {
+    return {
+      ok: false,
+      sliceId: slice.sliceId,
+      problems: [`active slice role is "${slice.role}", expected "${expectedRole}"`],
+      route: routeFor(slice, 'roleMismatch'),
+    };
+  }
+  const subdir = expectedRole === 'artist' ? 'slice-artist' : 'slice-ta';
+  const manifestPath = path.join(root, 'validate', subdir, `${slice.sliceId}.json`);
+  if (!fs.existsSync(manifestPath)) {
+    return {
+      ok: false,
+      sliceId: slice.sliceId,
+      problems: [`missing manifest ${path.relative(root, manifestPath)}`],
+      route: routeFor(slice, 'structureMissing'),
+      manifestPath,
+    };
+  }
+  let manifest;
+  try {
+    manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+  } catch (err) {
+    return {
+      ok: false,
+      sliceId: slice.sliceId,
+      problems: [`manifest parse failed: ${err.message}`],
+      route: routeFor(slice, 'structureMissing'),
+      manifestPath,
+    };
+  }
+  return { slice, manifest, manifestPath };
+}
+
+/** @param {string} root @param {string[]} refs */
+function missingArtifactPaths(root, refs) {
+  const problems = [];
+  for (const ref of refs) {
+    const rel = String(ref || '').trim();
+    if (!rel) {
+      problems.push('artifactRefs contains an empty path');
+      continue;
+    }
+    if (!fs.existsSync(path.join(root, rel))) {
+      problems.push(`artifact missing on disk: ${rel}`);
+    }
+  }
+  return problems;
+}
+
+/** @param {string} root */
+export function verifyArtistSliceStructure(root) {
+  const loaded = loadManifest(root, 'artist');
+  if (!loaded.ok && loaded.sliceId !== undefined && !loaded.manifest) {
+    return { ok: false, sliceId: loaded.sliceId, problems: loaded.problems, route: loaded.route };
+  }
+  if (!loaded.slice) {
+    return { ok: false, sliceId: loaded.sliceId, problems: loaded.problems, route: loaded.route };
+  }
+
+  const { slice, manifest, manifestPath } = loaded;
+  const problems = [];
+
+  if (manifest.sliceId && manifest.sliceId !== slice.sliceId) {
+    problems.push(`manifest sliceId "${manifest.sliceId}" !== active "${slice.sliceId}"`);
+  }
+  if (!String(manifest.styleIntent || '').trim()) {
+    problems.push('styleIntent is required (non-empty string)');
+  }
+  const scope = Array.isArray(manifest.scope) ? manifest.scope.map((s) => String(s).toLowerCase()) : [];
+  if (!scope.length || !scope.some((s) => ARTIST_SCOPE.has(s))) {
+    problems.push('scope must include at least one of: style, mc, asr');
+  }
+  if (!String(manifest.contextSummary || '').trim()) {
+    problems.push('contextSummary is required (one-line summary)');
+  }
+  const artifactRefs = Array.isArray(manifest.artifactRefs) ? manifest.artifactRefs : [];
+  if (!artifactRefs.length) {
+    problems.push('artifactRefs must list at least one produced context path');
+  }
+  problems.push(...missingArtifactPaths(root, artifactRefs));
+
+  if (problems.length) {
+    const failKey = problems.some((p) => p.startsWith('artifact missing')) ? 'artifactMissing' : 'structureMissing';
+    return { ok: false, sliceId: slice.sliceId, problems, route: routeFor(slice, failKey), manifestPath };
+  }
+  return { ok: true, sliceId: slice.sliceId, problems: [], route: null, manifestPath };
+}
+
+/** @param {string} root */
+export function verifyTaSliceStructure(root) {
+  const loaded = loadManifest(root, 'technical-artist');
+  if (!loaded.ok && loaded.sliceId !== undefined && !loaded.manifest) {
+    return { ok: false, sliceId: loaded.sliceId, problems: loaded.problems, route: loaded.route };
+  }
+  if (!loaded.slice) {
+    return { ok: false, sliceId: loaded.sliceId, problems: loaded.problems, route: loaded.route };
+  }
+
+  const { slice, manifest, manifestPath } = loaded;
+  const problems = [];
+
+  if (manifest.sliceId && manifest.sliceId !== slice.sliceId) {
+    problems.push(`manifest sliceId "${manifest.sliceId}" !== active "${slice.sliceId}"`);
+  }
+  const status = String(manifest.manifestStatus || '').toLowerCase();
+  if (!TA_STATUS.has(status)) {
+    problems.push('manifestStatus must be "ready" or "blocked"');
+  }
+  if (!String(manifest.contextSummary || '').trim()) {
+    problems.push('contextSummary is required (one-line summary)');
+  }
+  const pathMappings = Array.isArray(manifest.pathMappings) ? manifest.pathMappings : null;
+  if (!pathMappings) {
+    problems.push('pathMappings must be an array (contract path readiness table)');
+  } else {
+    for (const [i, row] of pathMappings.entries()) {
+      if (!row || typeof row !== 'object') {
+        problems.push(`pathMappings[${i}] must be an object`);
+        continue;
+      }
+      if (!String(row.contractPath || '').trim()) {
+        problems.push(`pathMappings[${i}].contractPath is required`);
+      }
+      if (!String(row.status || '').trim()) {
+        problems.push(`pathMappings[${i}].status is required (ready|missing|blocked)`);
+      }
+    }
+  }
+
+  const blockers = Array.isArray(manifest.blockers) ? manifest.blockers : [];
+  if (status === 'blocked') {
+    if (!blockers.length) {
+      problems.push('manifestStatus=blocked requires blockers[] with at least { key, reason }');
+    } else {
+      for (const [i, b] of blockers.entries()) {
+        if (!String(b?.key || '').trim() || !String(b?.reason || '').trim()) {
+          problems.push(`blockers[${i}] requires key and reason`);
+        }
+      }
+    }
+  } else if (status === 'ready' && pathMappings && pathMappings.length === 0) {
+    problems.push('manifestStatus=ready requires at least one pathMappings row');
+  }
+
+  if (problems.length) {
+    return {
+      ok: false,
+      sliceId: slice.sliceId,
+      problems,
+      route: routeFor(slice, 'structureMissing'),
+      manifestPath,
+    };
+  }
+  return { ok: true, sliceId: slice.sliceId, problems: [], route: null, manifestPath };
+}
+
+/** @param {{ ok: boolean, sliceId?: string|null, problems: string[], route?: object|null, manifestPath?: string }} result @param {string} label */
+export function writeStructureReport(root, result, label) {
+  try {
+    const dir = path.join(root, 'validate', label);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, `${result.sliceId || 'active'}.report.json`), `${JSON.stringify(result, null, 2)}\n`);
+  } catch {
+    /* ignore */
+  }
+}