@erclx/canon 5.65.0 → 5.67.0

package/src/take/zoom/region-utils.ts

@@ -0,0 +1,55 @@
+// Vendored from OpenScreen at ca8104c, MIT. See NOTICE.md beside this file.
+// Source: src/components/video-editor/videoPlayback/zoomRegionUtils.ts and the
+// two window constants from constants.ts. The zoom-out window and the chained
+// pan's duration carry the operator's tuning, and NOTICE.md lists both.
+
+import {
+  clamp01,
+  cubicBezier,
+  easeOutScreenStudio,
+} from '@/take/zoom/math-utils'
+
+/** OpenScreen's 1015.05 ms, shortened to 700 ms for a quicker zoom-out. */
+export const TRANSITION_WINDOW_MS = 700
+/** OpenScreen's zoom-in window, 1.5 times its original 1015.05 ms window. */
+export const ZOOM_IN_TRANSITION_WINDOW_MS = 1015.05 * 1.5
+
+export const CHAINED_ZOOM_PAN_GAP_MS = 1500
+/** OpenScreen's 1000 ms, shortened to 600 ms. */
+export const CONNECTED_ZOOM_PAN_DURATION_MS = 600
+export const ZOOM_IN_OVERLAP_MS = 500
+
+export interface ZoomRegion {
+  startMs: number
+  endMs: number
+}
+
+export function lerp(start: number, end: number, amount: number) {
+  return start + (end - start) * amount
+}
+
+export function easeConnectedPan(value: number) {
+  return cubicBezier(0.1, 0.0, 0.2, 1.0, value)
+}
+
+export function computeRegionStrength(region: ZoomRegion, timeMs: number) {
+  const zoomInEnd = region.startMs + ZOOM_IN_OVERLAP_MS
+  const leadInStart = zoomInEnd - ZOOM_IN_TRANSITION_WINDOW_MS
+  const leadOutEnd = region.endMs + TRANSITION_WINDOW_MS
+
+  if (timeMs < leadInStart || timeMs > leadOutEnd) {
+    return 0
+  }
+
+  if (timeMs < zoomInEnd) {
+    const progress = (timeMs - leadInStart) / ZOOM_IN_TRANSITION_WINDOW_MS
+    return easeOutScreenStudio(progress)
+  }
+
+  if (timeMs <= region.endMs) {
+    return 1
+  }
+
+  const progress = clamp01((timeMs - region.endMs) / TRANSITION_WINDOW_MS)
+  return 1 - easeOutScreenStudio(progress)
+}

package/src/take/zoom/spring.ts

@@ -0,0 +1,133 @@
+// Adapted from OpenScreen at ca8104c, MIT. See NOTICE.md beside this file.
+// Source: getZoomSpringConfig, stepSpringValue, and clampDeltaMs in
+// src/components/video-editor/videoPlayback/motionSmoothing.ts, and stepAxis in
+// zoomSpring.ts. OpenScreen steps its spring through the `motion` package, and
+// this solves the same damped spring in closed form instead, so a target
+// inherits no dependency for one function.
+
+export interface SpringState {
+  value: number
+  velocity: number
+  initialized: boolean
+}
+
+export interface SpringConfig {
+  stiffness: number
+  damping: number
+  mass: number
+  restDelta: number
+  restSpeed: number
+}
+
+export const ZOOM_SPRING: SpringConfig = {
+  stiffness: 320,
+  damping: 40,
+  mass: 0.92,
+  restDelta: 0.0005,
+  restSpeed: 0.015,
+}
+
+export function createSpringState(initialValue = 0): SpringState {
+  return { value: initialValue, velocity: 0, initialized: false }
+}
+
+export function clampDeltaMs(deltaMs: number, fallbackMs = 1000 / 60) {
+  if (!Number.isFinite(deltaMs) || deltaMs <= 0) {
+    return fallbackMs
+  }
+
+  return Math.min(80, Math.max(1, deltaMs))
+}
+
+/**
+ * Advances one axis toward `target` by `deltaMs`. The first call snaps to the
+ * target, a spring at rest stays there, and a step that would cross a moving
+ * target lands on it with no velocity, which keeps a quick chase from wobbling
+ * on a reversal.
+ */
+export function stepSpring(
+  state: SpringState,
+  target: number,
+  deltaMs: number,
+  config: SpringConfig = ZOOM_SPRING,
+): number {
+  if (!state.initialized || !Number.isFinite(state.value)) {
+    state.value = target
+    state.velocity = 0
+    state.initialized = true
+    return state.value
+  }
+
+  if (
+    Math.abs(target - state.value) <= config.restDelta &&
+    Math.abs(state.velocity) <= config.restSpeed
+  ) {
+    state.value = target
+    state.velocity = 0
+    return state.value
+  }
+
+  const before = state.value
+  const [offset, velocity] = solve(
+    state.value - target,
+    state.velocity,
+    clampDeltaMs(deltaMs) / 1000,
+    config,
+  )
+  const after = target + offset
+
+  const crossed =
+    (before <= target && after > target) || (before >= target && after < target)
+  if (crossed) {
+    state.value = target
+    state.velocity = 0
+    return target
+  }
+
+  state.value = after
+  state.velocity = velocity
+  return after
+}
+
+/**
+ * The displacement and velocity of a damped spring `seconds` after it sat at
+ * `x0` from rest length moving at `v0`, for each of the three damping regimes.
+ */
+function solve(
+  x0: number,
+  v0: number,
+  seconds: number,
+  { stiffness, damping, mass }: SpringConfig,
+): [number, number] {
+  const omega = Math.sqrt(stiffness / mass)
+  const zeta = damping / (2 * Math.sqrt(stiffness * mass))
+  const t = seconds
+
+  if (zeta < 1) {
+    const omegaD = omega * Math.sqrt(1 - zeta * zeta)
+    const decay = Math.exp(-zeta * omega * t)
+    const b = (v0 + zeta * omega * x0) / omegaD
+    const cos = Math.cos(omegaD * t)
+    const sin = Math.sin(omegaD * t)
+    const x = decay * (x0 * cos + b * sin)
+    const v =
+      decay *
+      (-zeta * omega * (x0 * cos + b * sin) + omegaD * (b * cos - x0 * sin))
+    return [x, v]
+  }
+
+  if (zeta === 1) {
+    const decay = Math.exp(-omega * t)
+    const b = v0 + omega * x0
+    return [(x0 + b * t) * decay, (b - omega * (x0 + b * t)) * decay]
+  }
+
+  const root = Math.sqrt(zeta * zeta - 1)
+  const r1 = -omega * (zeta - root)
+  const r2 = -omega * (zeta + root)
+  const c1 = (v0 - r2 * x0) / (r1 - r2)
+  const c2 = x0 - c1
+  const e1 = Math.exp(r1 * t)
+  const e2 = Math.exp(r2 * t)
+  return [c1 * e1 + c2 * e2, c1 * r1 * e1 + c2 * r2 * e2]
+}

package/src/tasks/archive.ts

@@ -7,6 +7,7 @@ import { regenOne } from '@/indexes/regen'
 import { rerenderRow } from '@/tasks/board'
 import { planBranch } from '@/tasks/branch'
 import { isUnder } from '@/tasks/paths'
+import { SESSION_MAP_PREFIX } from '@/records/session-map'
 import { recordDir, recordDirs } from '@/roots/record'
 
 const TASKS = 'tasks'
@@ -29,9 +30,6 @@ export const RESERVED_STEMS = [
   'session',
 ] as const
 
-/** The pre-compaction handoff takes one file per session, so its stems vary. */
-const SESSION_MAP_PREFIX = 'session-'
-
 export function isReservedStem(stem: string): boolean {
   const reserved: readonly string[] = RESERVED_STEMS
 

package/src/tooling/verify-stack.ts

@@ -95,19 +95,18 @@ async function run({
   logStep(`Scaffolding ${stack}`)
   // Manifests carry shell syntax (`&&`, `cd`, quoted globs), so the command
   // runs under a shell rather than as a split argv.
-  const scaffold = await shell(
-    manifest.scaffold.replaceAll('{{name}}', name),
-    runsDir,
-  )
+  const scaffoldCommand = manifest.scaffold.replaceAll('{{name}}', name)
+  const scaffold = await shell(scaffoldCommand, runsDir)
   if (scaffold.failed) {
     logWarn('Scaffold failed')
+    process.stderr.write(`$ ${scaffoldCommand}\n`)
     writeTail(scaffold.all)
-    state.isFailed = true
   }
 
   if (!existsSync(state.dir)) {
     return refuse(`Scaffold did not produce ${state.dir}`)
   }
+  record(state, 'Scaffold', !scaffold.failed)
 
   await shell(
     'git init -q && git add . && git commit -m "chore: verify scaffold" -q --no-verify --allow-empty',

package/tooling/base/reference.md

@@ -39,6 +39,7 @@ Seeds live in `tooling/base/seeds/`. Sync drops each once on first install and n
 - `.github/workflows/verify.yml` runs on pull requests targeting `main` and on `workflow_dispatch`. A multi-root project adds its own jobs here.
 - `.github/pull_request_template.md` has `## Summary`, `## Key changes`, `## Technical context`, and `## Testing`. A project adds its own checklist lines.
 - `canon/context/development/` holds the `setup` and `ci` entries under a folder index. Extend them with project-specific commands and workflows, and keep canonical rationale here.
+- `canon/config/pr-labels.toml` is the starter pull request label map, covering what the toolkit installs. A project adds a row per surface of its own.
 
 ## Tool pairing
 

package/tooling/base/seeds/canon/config/pr-labels.toml

@@ -0,0 +1,41 @@
+# Pull request domain labels.
+#
+# `git-pr` matches the paths a branch changed against the prefixes below and
+# applies every label that matches. The rows here cover what the toolkit
+# installs. Add a row per surface of your own, such as `app = ["src/"]`, and
+# `canon labels audit` names any changed path no row reaches.
+#
+# Each label has to exist on the remote before a pull request can carry it.
+# Run `canon labels sync` once to create the ones the remote lacks, and again
+# after adding a row.
+#
+# The matching rule and the `[declined]` table are described in the `git-pr`
+# skill's labels reference.
+
+[domains]
+tooling = [
+  ".github/",
+  ".husky/",
+  "scripts/",
+  ".gitignore",
+  ".lintstagedrc",
+  ".oxfmtrc.json",
+  ".prettierignore",
+  "commitlint.config.js",
+  "package.json",
+  "bun.lock",
+  "canon/config/",
+]
+claude = [".claude/", "CLAUDE.md"]
+docs = [
+  "README.md",
+  "docs/",
+  "canon/REQUIREMENTS.md",
+  "canon/DESIGN.md",
+  "canon/context/",
+]
+
+# Paths deliberately left unlabelled, keyed by the reason.
+[declined]
+# Release automation opens its own pull request and applies its own label.
+release-managed = ["CHANGELOG.md", ".release-please-manifest.json"]

package/claude/skills/review-ui/scripts/pw.sh

@@ -1,60 +0,0 @@
-#!/usr/bin/env bash
-# Pins the agent browser CLI the UI pass drives through, so every call in a run
-# and every run on a machine reach one version. `open` is forced onto the
-# bundled Chromium, since the CLI's default channel is a branded Chrome most
-# machines lack, and it refuses rather than downloading when that browser is
-# absent, since a dispatched reviewer that installs mid-pass spends its budget
-# on the download.
-set -euo pipefail
-
-PW_CLI="@playwright/cli@0.1.22"
-# The Chromium revision that CLI version requires. It moves with the pin, and
-# it is separate from the revision any other Playwright on the machine uses.
-PW_CHROMIUM_REVISION="1247"
-
-die() {
-  echo "pw.sh: $*" >&2
-  exit 1
-}
-
-browsers_root() {
-  if [ -n "${PLAYWRIGHT_BROWSERS_PATH:-}" ]; then
-    echo "$PLAYWRIGHT_BROWSERS_PATH"
-  elif [ "$(uname -s 2>/dev/null || echo unknown)" = Darwin ]; then
-    echo "$HOME/Library/Caches/ms-playwright"
-  else
-    echo "$HOME/.cache/ms-playwright"
-  fi
-}
-
-command -v bunx >/dev/null 2>&1 || die "bunx is not on PATH, so the pinned CLI cannot run"
-
-# Global flags may lead the verb, as in `-s=<name> --raw open <url>`.
-args=("$@")
-verb_at=0
-for i in "${!args[@]}"; do
-  case "${args[$i]}" in
-  -*) ;;
-  *)
-    verb_at=$i
-    break
-    ;;
-  esac
-done
-
-if [ "${args[$verb_at]:-}" = open ]; then
-  if [ ! -d "$(browsers_root)/chromium-$PW_CHROMIUM_REVISION" ]; then
-    die "Chromium revision $PW_CHROMIUM_REVISION is not installed. Run once, outside the pass: bunx -y $PW_CLI install-browser chromium"
-  fi
-  has_browser=false
-  for arg in "${args[@]}"; do
-    case "$arg" in
-    --browser=* | --browser) has_browser=true ;;
-    esac
-  done
-  if [ "$has_browser" = false ]; then
-    args=("${args[@]:0:$((verb_at + 1))}" --browser=chromium "${args[@]:$((verb_at + 1))}")
-  fi
-fi
-
-exec bunx -y "$PW_CLI" "${args[@]}"