rig-c 0.0.0-stage → 2.21.0

package/bin/rigc.cjs

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * rigc's `bin` entry has one job: hand off to Bun.
+ *
+ * npm's `bin` field has to be something any installed Node can run, but rigc
+ * itself is a Bun script (top-level await, Bun's own APIs) — its own shebang
+ * says so. On a machine without Bun that used to fail as a bare
+ * `env: bun: No such file or directory`, with no hint why. This file exists
+ * so that failure explains itself: if `bun` is on PATH, run the real CLI
+ * (cli.ts, next to this file) under it and disappear — argv, stdio, the exit
+ * code and signals all pass straight through. If it isn't, say so once and
+ * stop. No downloads, no network, no writes — just the hand-off or the
+ * message.
+ *
+ * ## Which entry (issue #1061)
+ *
+ * `@esotericsoftware/spine-core` is a devDependency: a clone and CI have it, an
+ * install of the package does not unless somebody adds it beside. So the
+ * hand-off has two targets and one rule. When the runtime resolves from this
+ * package's own location — Node's resolution, from the package root, which is
+ * what an import in `cli.ts` would find — the target is `cli.ts`, every
+ * command, the round trip included. When it does not, the target is
+ * `cli_core.ts`, the entry that links nothing of the runtime and refuses by
+ * name the commands that need it. Nothing else chooses: no environment
+ * variable, no flag. `--version` says which ran and why, on stderr, so the
+ * version on stdout stays one line a script can read.
+ */
+
+const path = require('node:path');
+const fs = require('node:fs');
+const { spawnSync } = require('node:child_process');
+
+const root = path.join(__dirname, '..');
+const RUNTIME = '@esotericsoftware/spine-core';
+
+/** The runtime's version where it resolves from the package root, or null where it does not. */
+function runtimeVersion() {
+  let manifest;
+  try {
+    manifest = require.resolve(`${RUNTIME}/package.json`, { paths: [root] });
+  } catch {
+    return null;
+  }
+  try {
+    const version = JSON.parse(fs.readFileSync(manifest, 'utf8')).version;
+    return typeof version === 'string' ? version : '(no version field)';
+  } catch {
+    return '(unreadable package.json)';
+  }
+}
+
+const present = runtimeVersion();
+const entry = present === null ? 'cli_core.ts' : 'cli.ts';
+const args = process.argv.slice(2);
+const result = spawnSync('bun', [path.join(root, entry), ...args], { stdio: 'inherit' });
+
+if (!result.error && result.status === 0 && args.length === 1 && (args[0] === '--version' || args[0] === '-v')) {
+  process.stderr.write(
+    present === null
+      ? `entry: ${entry} — ${RUNTIME} absent — the round trip and the commands that need it are not available here; see --help\n`
+      : `entry: ${entry} — ${RUNTIME} ${present} present\n`,
+  );
+}
+
+if (result.error) {
+  if (result.error.code === 'ENOENT') {
+    process.stderr.write('rigc runs on Bun, which was not found on PATH — install it from https://bun.sh\n');
+  } else {
+    process.stderr.write(`rigc: could not launch bun: ${result.error.message}\n`);
+  }
+  process.exit(1);
+}
+
+if (result.signal) {
+  // A signal (e.g. Ctrl-C) killed the child — die the same way instead of
+  // inventing an exit code, so the caller sees the same thing it would have
+  // seen running bun directly.
+  process.kill(process.pid, result.signal);
+} else {
+  process.exit(typeof result.status === 'number' ? result.status : 1);
+}

package/cli.ts

@@ -0,0 +1,61 @@
+#!/usr/bin/env bun
+/**
+ * rigc — the rig compiler.
+ *
+ *   bun cli.ts build --rig <path> --motion <path> --out <dir> [--manifest <path>]
+ *   bun cli.ts build --cut <name> --cuts <cuts.json>
+ *   bun cli.ts explain --rig <path> --motion <path> --out <dir>
+ *   bun cli.ts explain --cut <name> --cuts <cuts.json>
+ *   bun cli.ts validate <dir>            re-run the gate on artifacts on disk
+ *   bun cli.ts check --candidate <dir> --frames <dir>   compare against pictures
+ *
+ * `build` emits ONLY if validate is green. That ordering is the point: the
+ * compiler is allowed to be wrong, it is not allowed to leave the wrong thing
+ * on disk.
+ *
+ * ⚠️ Green is a claim about VALIDITY and about nothing else. The gate has no way
+ * to know whether the animation is the one that was asked for — a build with
+ * every easing reversed passes it — so `check` is the other half of the loop, and
+ * it is a separate command because it needs something the gate does not have: a
+ * picture of what the result is supposed to look like.
+ *
+ * rigc knows nothing about any particular project. A cut is a rig spec, a motion
+ * spec and an output directory — plus a cut manifest when there is measured art
+ * behind it — and a `cuts.json` is a named table of them:
+ *
+ *   {
+ *     "my_cut": { "rig": "…/rigs/my_rig.rig.json", "motion": "…/my.motion.json",
+ *                 "out": "…/spine", "manifest": "…/manifest.json" }
+ *   }
+ *
+ * Its paths resolve against the cuts.json file itself, so the table travels
+ * with the project that owns the art rather than with this repository.
+ */
+import { PROFILE_RULES, SPINE_COMMAND_REFUSALS, SPINE_COMMAND_RUNS } from './src/cli/spine_commands.ts';
+import { CORE_COMMAND_RUNS } from './src/cli/core_commands.ts';
+import { runCli } from './src/cli/shared.ts';
+// The Spine side of the seam (issue #1052): loading the modules that link spine-core registers what they pose and read
+// through it — an export's poser and loader, `--poser spine`, a fallback, the deform survey through the runtime — into
+// `src/spine_side.ts`, which the commands below reach it through.
+import './src/render.ts';
+import './src/deformmeasure.ts';
+
+/**
+ * One entry of a cuts.json, every path relative to the cuts.json file — the
+ * shape `src/cli/shared.ts` reads, re-exported where it was always declared.
+ */
+export type { CutEntry, CutTable } from './src/cli/shared.ts';
+
+// ⭐ Every command, every refusal and every exit code as they always were: the dispatch, the documentation and the
+// bodies moved to `src/cli/` unchanged (issue #1052), and this entry registers all of them. `cli_core.ts` registers the
+// commands whose bodies reach nothing of the runtime, and links none of it.
+runCli(
+  {
+    checkout: 'cli.ts',
+    linksRuntime: true,
+    runs: { ...CORE_COMMAND_RUNS, ...SPINE_COMMAND_RUNS },
+    profileRules: PROFILE_RULES,
+    refusals: SPINE_COMMAND_REFUSALS,
+  },
+  process.argv.slice(2),
+);

package/cli_core.ts

@@ -0,0 +1,46 @@
+#!/usr/bin/env bun
+/**
+ * rigc's second entry: the commands that reach nothing of spine-core (issue
+ * #1052, step 4e of #380).
+ *
+ *   bun cli_core.ts render --candidate <dir> [flags]
+ *   bun cli_core.ts check --candidate <dir> --frames <dir> [flags]
+ *   bun cli_core.ts --help                 the commands this entry runs
+ *
+ * Which commands those are is not listed here: it is every command whose
+ * `runtime` is `false` in the one command table (`src/cli/shared.ts`), and
+ * every one whose `runtime` states a second body (`runtime.core`, below), and
+ * `--help` prints exactly that set. This file imports nothing that links the
+ * runtime — no module it reaches, statically, imports
+ * `@esotericsoftware/spine-core` — so it runs with the package absent
+ * (`RC24`/`RC25` in `selftest.ts` build that state and hold it). Each command
+ * prints and writes what `cli.ts` prints and writes for it.
+ *
+ * 📦 It is also what an install runs (issue #1061): `bin/rigc.cjs` hands `rigc`
+ * to this file wherever `@esotericsoftware/spine-core` does not resolve from the
+ * package — a devDependency, so every install until somebody adds it beside —
+ * and to `cli.ts` wherever it does. So the texts this entry prints are read in a
+ * clone and in an install alike, and where one names the entry that links the
+ * runtime it names both routes to it (issue #1072): installed, the same `rigc`
+ * once the runtime is installed beside the package; from a source checkout,
+ * `bun cli.ts`.
+ *
+ * ⚠️ What it cannot do, and refuses by name rather than reaching for: an input
+ * only the runtime reads — a Spine export, `--poser spine`, a fallback the
+ * poser line names, the deform survey of a build the core refuses — and a
+ * command whose body is the runtime's (`validate`, `bench`, `bonedist`,
+ * `preview`, `vote`). Both say what they needed spine-core for and that this
+ * entry links none of it; the command's refusal also names the two routes to
+ * the entry that runs it.
+ *
+ * `build` is the one name with a body here of its own (issue #1060,
+ * `CORE_ENTRY_RUNS`): `cli.ts build`'s body (`runBuild`), writing the same
+ * files, with another gate — the model side over the document and the round
+ * trip's own rules restated over the emitted text, A00 (spine-core's parse) a
+ * SKIP naming it. `--help` and `build --help` say so; the command table states
+ * it (`runtime.core` in `src/cli/shared.ts`).
+ */
+import { CORE_COMMAND_RUNS, CORE_ENTRY_RUNS } from './src/cli/core_commands.ts';
+import { runCli } from './src/cli/shared.ts';
+
+runCli({ checkout: 'cli_core.ts', linksRuntime: false, runs: { ...CORE_COMMAND_RUNS, ...CORE_ENTRY_RUNS } }, process.argv.slice(2));