Remove the wright-workshop cutover adapter (complete the wright#143 removal path)

CONTRIBUTING.md

@@ -47,7 +47,7 @@ not enable Clippy's `pedantic`, `nursery`, or `restriction` groups.
 
 This policy was audited against the workspace manifests, CI, and representative
 compiler/tooling crates (`wright-ir`, `wright-core`, `wright-driver`,
-`wright-opy`, `wright-workshop`, `wright-language`, and `wright-lsp`):
+`wright-opy`, `wright-language`, and `wright-lsp`):
 
 * Semantic identities use typed IR IDs and arena lookups; raw strings remain at
   protocol, source-name, and presentation boundaries. New public contracts

Cargo.toml

@@ -1,5 +1,5 @@
 [workspace]
-members = ["crates/wright-core", "crates/wright-ir", "crates/wright-analyzer", "crates/wright-workshop", "crates/wright-driver", "crates/wright-cli", "crates/wright-opy", "crates/wright-ostw", "crates/wright-transform", "crates/wright-bench", "crates/wright-consumer", "crates/wright-language", "crates/wright-lsp", "crates/wright-lpp"]
+members = ["crates/wright-core", "crates/wright-ir", "crates/wright-analyzer", "crates/wright-driver", "crates/wright-cli", "crates/wright-opy", "crates/wright-ostw", "crates/wright-transform", "crates/wright-bench", "crates/wright-consumer", "crates/wright-language", "crates/wright-lsp", "crates/wright-lpp"]
 resolver = "3"
 
 [workspace.package]

crates/wright-analyzer/Cargo.toml

@@ -14,6 +14,5 @@ serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 wright-core = { path = "../wright-core" }
 wright-ir = { path = "../wright-ir" }
-wright-workshop = { path = "../wright-workshop" }
 # Single pinned reference: `[workspace.dependencies]` in the root Cargo.toml.
 workshop-rs.workspace = true

crates/wright-analyzer/src/bin/wright-tool.rs

@@ -19,10 +19,10 @@
 use std::io::{BufRead, Write};
 use std::process::ExitCode;
 
+use workshop_rs::catalog::{Catalog, Locale};
+use workshop_rs::{detect, parser};
 use wright_analyzer::service::SemanticService;
 use wright_ir::lower;
-use wright_workshop::catalog::{Catalog, Locale};
-use wright_workshop::{detect, parser};
 
 enum Input {
     Protocol(wright_core::hir::Program),

crates/wright-analyzer/src/service.rs

@@ -115,7 +115,7 @@ impl<'a> SemanticService<'a> {
             program,
             Origin {
                 kind: "workshop".to_string(),
-                locale: Some(wright_workshop::catalog::Locale::new(locale).to_string()),
+                locale: Some(workshop_rs::catalog::Locale::new(locale).to_string()),
             },
         )
     }

crates/wright-analyzer/tests/workshop_integration.rs

@@ -8,9 +8,9 @@ use std::path::{Path, PathBuf};
 use std::process::{Command, Stdio};
 
 use serde_json::Value;
+use workshop_rs::catalog::{Catalog, Locale};
+use workshop_rs::parser;
 use wright_analyzer::service::SemanticService;
-use wright_workshop::catalog::{Catalog, Locale};
-use wright_workshop::parser;
 
 fn oracle_path(fixture_id: &str) -> PathBuf {
     Path::new(env!("CARGO_MANIFEST_DIR"))

crates/wright-driver/Cargo.toml

@@ -20,6 +20,5 @@ wright-lpp = { path = "../wright-lpp" }
 wright-opy = { path = "../wright-opy" }
 wright-ostw = { path = "../wright-ostw" }
 wright-transform = { path = "../wright-transform" }
-wright-workshop = { path = "../wright-workshop" }
 # Single released reference: `[workspace.dependencies]` in the root Cargo.toml.
 workshop-rs.workspace = true

crates/wright-driver/src/service.rs

@@ -532,16 +532,16 @@ impl<'a> ToolService<'a> {
     /// Compiler-host performance is measured by the `wright-bench` harness, not
     /// in-process.
     fn cost_estimate(&self) -> serde_json::Value {
-        let catalog = wright_workshop::catalog::Catalog::builtin().expect("built-in catalog loads");
+        let catalog = workshop_rs::catalog::Catalog::builtin().expect("built-in catalog loads");
         let locale = self
             .loaded
             .origin
             .locale
             .clone()
-            .map(|locale| wright_workshop::catalog::Locale::new(&locale))
-            .unwrap_or_else(|| wright_workshop::catalog::Locale::new("en-US"));
-        let text = wright_workshop::emitter::emit(&self.loaded.program, &catalog, &locale)
-            .unwrap_or_default();
+            .map(|locale| workshop_rs::catalog::Locale::new(&locale))
+            .unwrap_or_else(|| workshop_rs::catalog::Locale::new("en-US"));
+        let text =
+            workshop_rs::emitter::emit(&self.loaded.program, &catalog, &locale).unwrap_or_default();
         let waits = self
             .loaded
             .program
@@ -575,7 +575,7 @@ impl<'a> ToolService<'a> {
 
     /// Target/catalog metadata for reasoning about Workshop operations.
     fn target_metadata(&self) -> serde_json::Value {
-        let catalog = match wright_workshop::catalog::Catalog::builtin() {
+        let catalog = match workshop_rs::catalog::Catalog::builtin() {
             Ok(catalog) => catalog,
             Err(error) => {
                 return json!({ "error": error.to_string() });
@@ -584,10 +584,10 @@ impl<'a> ToolService<'a> {
         json!({
             "catalogVersion": catalog.schema_version,
             "locales": catalog.locales().iter().map(|l| l.to_string()).collect::<Vec<_>>(),
-            "actions": catalog.entries_of(wright_workshop::catalog::Kind::Action).count(),
-            "values": catalog.entries_of(wright_workshop::catalog::Kind::Value).count(),
-            "events": catalog.entries_of(wright_workshop::catalog::Kind::Event).count(),
-            "operators": catalog.entries_of(wright_workshop::catalog::Kind::Operator).count(),
+            "actions": catalog.entries_of(workshop_rs::catalog::Kind::Action).count(),
+            "values": catalog.entries_of(workshop_rs::catalog::Kind::Value).count(),
+            "events": catalog.entries_of(workshop_rs::catalog::Kind::Event).count(),
+            "operators": catalog.entries_of(workshop_rs::catalog::Kind::Operator).count(),
             "enumDomains": catalog.enum_domains().map(|domain| json!({
                 "domain": domain.domain,
                 "members": domain.members.iter().map(|m| m.member.clone()).collect::<Vec<_>>(),

crates/wright-driver/src/session.rs

@@ -49,15 +49,15 @@ pub struct Loaded {
 pub struct CompilerSession {
     /// The session configuration (input, frontend, overrides, format).
     pub config: SessionConfig,
-    catalog: wright_workshop::catalog::Catalog,
+    catalog: workshop_rs::catalog::Catalog,
     loaded: Option<Loaded>,
     diagnostics: Vec<Diagnostic>,
 }
 
 impl CompilerSession {
     /// Build a session from a configuration.
     pub fn new(config: SessionConfig) -> Result<CompilerSession, Diagnostic> {
-        let catalog = wright_workshop::catalog::Catalog::builtin().map_err(|error| {
+        let catalog = workshop_rs::catalog::Catalog::builtin().map_err(|error| {
             Diagnostic::error(
                 "catalog-error",
                 Stage::Internal,
@@ -244,8 +244,8 @@ impl CompilerSession {
             .config
             .locale
             .as_deref()
-            .map(wright_workshop::catalog::Locale::new);
-        let locale = wright_workshop::detect::resolve_locale(
+            .map(workshop_rs::catalog::Locale::new);
+        let locale = workshop_rs::detect::resolve_locale(
             &resolved.text,
             &self.catalog,
             override_locale.as_ref(),
@@ -266,7 +266,7 @@ impl CompilerSession {
             )
         })?;
         let context = wright_core::signatures::ChainedExpectedDomain::new(manifest, &self.catalog);
-        let program = wright_workshop::parser::parse_with_context(
+        let program = workshop_rs::parser::parse_with_context(
             &resolved.text,
             &self.catalog,
             &locale,
@@ -376,9 +376,9 @@ impl CompilerSession {
             .origin
             .locale
             .clone()
-            .map(|locale| wright_workshop::catalog::Locale::new(&locale))
-            .unwrap_or_else(|| wright_workshop::catalog::Locale::new("en-US"));
-        let text = wright_workshop::emitter::emit(&loaded.program, &self.catalog, &locale)
+            .map(|locale| workshop_rs::catalog::Locale::new(&locale))
+            .unwrap_or_else(|| workshop_rs::catalog::Locale::new("en-US"));
+        let text = workshop_rs::emitter::emit(&loaded.program, &self.catalog, &locale)
             .map_err(|error| workshop_diag(error, &loaded.input))?;
         let sha256 = input_identity(&text);
         Ok(CompiledOutput {
@@ -946,16 +946,16 @@ fn root_relative(path: Option<&Path>, root: &Path) -> Option<String> {
 }
 
 /// Map a Workshop-language error to a driver diagnostic.
-fn workshop_diag(error: wright_workshop::WorkshopError, resolved: &ResolvedInput) -> Diagnostic {
+fn workshop_diag(error: workshop_rs::WorkshopError, resolved: &ResolvedInput) -> Diagnostic {
     let (code, stage, span) = match &error {
-        wright_workshop::WorkshopError::Catalog(catalog) => {
+        workshop_rs::WorkshopError::Catalog(catalog) => {
             return Diagnostic::error(
                 "catalog-error",
                 Stage::Internal,
                 format!("{}: {}", catalog.code, catalog.message),
             );
         }
-        wright_workshop::WorkshopError::Unknown { kind, span, .. } => (
+        workshop_rs::WorkshopError::Unknown { kind, span, .. } => (
             format!("unknown-{kind}"),
             Stage::Frontend,
             span.map(|span| SourceSpan {
@@ -971,7 +971,7 @@ fn workshop_diag(error: wright_workshop::WorkshopError, resolved: &ResolvedInput
                 },
             }),
         ),
-        wright_workshop::WorkshopError::Malformed { span, .. } => (
+        workshop_rs::WorkshopError::Malformed { span, .. } => (
             "parse-error".to_string(),
             Stage::Frontend,
             span.map(|span| SourceSpan {
@@ -987,7 +987,7 @@ fn workshop_diag(error: wright_workshop::WorkshopError, resolved: &ResolvedInput
                 },
             }),
         ),
-        wright_workshop::WorkshopError::Unsupported { span, .. } => (
+        workshop_rs::WorkshopError::Unsupported { span, .. } => (
             "unsupported-construct".to_string(),
             Stage::Frontend,
             span.map(|span| SourceSpan {
@@ -1007,7 +1007,7 @@ fn workshop_diag(error: wright_workshop::WorkshopError, resolved: &ResolvedInput
         // a first-class error (ADR-0001 Decision 7; wright#143): conversion
         // or emission into a locale without a mapping is a diagnostic, never
         // a guess or a silent passthrough.
-        wright_workshop::WorkshopError::MissingMapping { kind, id, locale } => (
+        workshop_rs::WorkshopError::MissingMapping { kind, id, locale } => (
             "missing-mapping".to_string(),
             Stage::Frontend,
             Diagnostic::error(

crates/wright-driver/tests/convert.rs

@@ -5,7 +5,7 @@
 //! proves both reverse loops through the real native frontends:
 //!
 //! * `Workshop → convert(opy) → native wright-opy frontend → HIR → WIR →
-//!   Workshop` — equivalence under `wright_workshop::roundtrip::equivalent`
+//!   Workshop` — equivalence under `workshop_rs::roundtrip::equivalent`
 //!   (the #124 contract, no normalization);
 //! * `Workshop → convert(ostw) → native wright-ostw frontend (generated
 //!   `ds.toml` project root) → HIR → WIR → Workshop` — equivalence under the
@@ -58,14 +58,14 @@ fn sha256(input: &str) -> String {
 
 /// Parse Workshop text through the shared parser with the canonical
 /// signature context (the same path the driver uses).
-fn parse(catalog: &wright_workshop::catalog::Catalog, text: &str) -> wir::Program {
+fn parse(catalog: &workshop_rs::catalog::Catalog, text: &str) -> wir::Program {
     let manifest =
         wright_opy::manifest::Manifest::builtin().expect("the OPY manifest is embedded and valid");
     let context = wright_core::signatures::ChainedExpectedDomain::new(manifest, catalog);
-    let program = wright_workshop::parser::parse_with_context(
+    let program = workshop_rs::parser::parse_with_context(
         text,
         catalog,
-        &wright_workshop::catalog::Locale::new("en-US"),
+        &workshop_rs::catalog::Locale::new("en-US"),
         &context,
     )
     .unwrap_or_else(|error| panic!("fixture Workshop text must parse: {error}"));
@@ -129,13 +129,13 @@ fn compile_reconstructed_ostw(ostw_text: &str, test_name: &str) -> wright_ir::hi
 
 /// Emit Workshop text for a WIR program through the shared emitter.
 fn emit_workshop(
-    catalog: &wright_workshop::catalog::Catalog,
+    catalog: &workshop_rs::catalog::Catalog,
     program: &wir::Program,
 ) -> Result<String, String> {
-    wright_workshop::emitter::emit(
+    workshop_rs::emitter::emit(
         program,
         catalog,
-        &wright_workshop::catalog::Locale::new("en-US"),
+        &workshop_rs::catalog::Locale::new("en-US"),
     )
     .map_err(|error| error.to_string())
 }
@@ -538,7 +538,7 @@ fn normalize(program: &mut wir::Program) {
 
 /// The full Workshop → OPY loop through the shared driver path.
 fn opy_round_trip(
-    catalog: &wright_workshop::catalog::Catalog,
+    catalog: &workshop_rs::catalog::Catalog,
     fixture: &str,
     failures: &mut Vec<String>,
 ) -> serde_json::Value {
@@ -579,7 +579,7 @@ fn opy_round_trip(
             return serde_json::json!({ "status": "lower-failed" });
         }
     };
-    let equivalent = wright_workshop::roundtrip::equivalent(&original, &recompiled);
+    let equivalent = workshop_rs::roundtrip::equivalent(&original, &recompiled);
     if !equivalent {
         failures.push(format!("{fixture}: recompiled WIR is not equivalent"));
     }
@@ -606,7 +606,7 @@ fn opy_round_trip(
 
 /// The full Workshop → OSTW loop through the shared driver path.
 fn ostw_round_trip(
-    catalog: &wright_workshop::catalog::Catalog,
+    catalog: &workshop_rs::catalog::Catalog,
     fixture: &str,
     failures: &mut Vec<String>,
 ) -> serde_json::Value {
@@ -669,7 +669,7 @@ fn ostw_round_trip(
     let mut reference = original;
     normalize(&mut actual);
     normalize(&mut reference);
-    let equivalent = wright_workshop::roundtrip::equivalent(&actual, &reference);
+    let equivalent = workshop_rs::roundtrip::equivalent(&actual, &reference);
     if !equivalent {
         failures.push(format!(
             "{fixture}: normalized recompiled WIR is not equivalent"
@@ -690,7 +690,7 @@ fn ostw_round_trip(
 
 #[test]
 fn cross_format_conversion_round_trips_and_reports() {
-    let catalog = wright_workshop::catalog::Catalog::builtin().expect("catalog loads");
+    let catalog = workshop_rs::catalog::Catalog::builtin().expect("catalog loads");
     let mut failures = Vec::new();
     let mut report = serde_json::Map::new();
     for fixture in OPY_FIXTURES {
@@ -784,7 +784,7 @@ fn rejection_entry(
 
 #[test]
 fn conversion_is_byte_deterministic_across_runs() {
-    let catalog = wright_workshop::catalog::Catalog::builtin().expect("catalog loads");
+    let catalog = workshop_rs::catalog::Catalog::builtin().expect("catalog loads");
     for (target, fixture) in [
         (
             ConvertTarget::Opy,