diff --git a/Cargo.lock b/Cargo.lock
index 0f6ef1a..9e2d3b6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1882,6 +1882,7 @@ dependencies = [
  "parking_lot 0.11.2",
  "preserves",
  "preserves-schema",
+ "syndicate-schema-plugin",
  "tokio",
  "tokio-util",
  "tracing",
@@ -1905,8 +1906,9 @@ dependencies = [
 name = "syndicate-schema-plugin"
 version = "0.9.0"
 dependencies = [
+ "lazy_static",
+ "preserves",
  "preserves-schema",
- "syndicate",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index 6096fb7..260a1f7 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -2,9 +2,9 @@ cargo-features = ["strip"]
 
 [workspace]
 members = [
+  "syndicate-schema-plugin",
   "syndicate",
   "syndicate-macros",
-  "syndicate-schema-plugin",
   "syndicate-server",
   "syndicate-tools",
   ]
diff --git a/syndicate-schema-plugin/Cargo.toml b/syndicate-schema-plugin/Cargo.toml
index bd3d1d9..71efdf7 100644
--- a/syndicate-schema-plugin/Cargo.toml
+++ b/syndicate-schema-plugin/Cargo.toml
@@ -11,9 +11,13 @@ license = "Apache-2.0"
 
 [lib]
 
-[dependencies]
+[build-dependencies]
 preserves-schema = "5.995"
-syndicate = { path = "../syndicate", version = "0.40.0"}
+
+[dependencies]
+preserves = "4.995"
+preserves-schema = "5.995"
+lazy_static = "1.4"
 
 [package.metadata.workspaces]
 independent = true
diff --git a/syndicate-schema-plugin/build.rs b/syndicate-schema-plugin/build.rs
new file mode 100644
index 0000000..21813c1
--- /dev/null
+++ b/syndicate-schema-plugin/build.rs
@@ -0,0 +1,15 @@
+use preserves_schema::compiler::*;
+
+fn main() -> std::io::Result<()> {
+    let buildroot = std::path::PathBuf::from(std::env::var_os("OUT_DIR").unwrap());
+
+    let mut gen_dir = buildroot.clone();
+    gen_dir.push("src/schemas");
+
+    let mut c = CompilerConfig::new("crate::schemas".to_owned());
+    c.add_external_module(ExternalModule::new(vec!["EntityRef".to_owned()], "crate::placeholder"));
+
+    let inputs = expand_inputs(&vec!["../syndicate/protocols/schema-bundle.bin".to_owned()])?;
+    c.load_schemas_and_bundles(&inputs, &vec![])?;
+    compile(&c, &mut CodeCollector::files(gen_dir))
+}
diff --git a/syndicate-schema-plugin/src/lib.rs b/syndicate-schema-plugin/src/lib.rs
index af1c55f..46d4533 100644
--- a/syndicate-schema-plugin/src/lib.rs
+++ b/syndicate-schema-plugin/src/lib.rs
@@ -1,3 +1,25 @@
-mod pattern_plugin;
+use std::sync::Arc;
+use preserves::value::ArcValue;
+use preserves::value::Domain;
 
+mod schemas {
+    //! Auto-generated codecs for [Syndicate protocol
+    //! schemas](https://git.syndicate-lang.org/syndicate-lang/syndicate-protocols/src/branch/main/schemas).
+    include!(concat!(env!("OUT_DIR"), "/src/schemas/mod.rs"));
+}
+
+mod placeholder {
+    pub type Cap = super::Cap;
+}
+
+#[derive(Debug, Clone, Hash, Ord, Eq, PartialOrd, PartialEq)]
+pub enum Cap {}
+impl Domain for Cap {}
+
+preserves_schema::define_language!(language(): Language<ArcValue<Arc<Cap>>> {
+    syndicate: schemas::Language,
+});
+
+mod pattern;
+mod pattern_plugin;
 pub use pattern_plugin::PatternPlugin;
diff --git a/syndicate-schema-plugin/src/pattern.rs b/syndicate-schema-plugin/src/pattern.rs
new file mode 100644
index 0000000..ddc5318
--- /dev/null
+++ b/syndicate-schema-plugin/src/pattern.rs
@@ -0,0 +1,35 @@
+use crate::schemas::dataspace_patterns::*;
+
+use preserves::value::NestedValue;
+use preserves::value::Value;
+
+pub fn lift_literal<N: NestedValue>(v: &N) -> Pattern<N> {
+    match v.value() {
+        Value::Boolean(b) => Pattern::Lit { value: Box::new(AnyAtom::Bool(*b)) },
+        Value::Double(d) => Pattern::Lit { value: Box::new(AnyAtom::Double(*d)) },
+        Value::SignedInteger(i) => Pattern::Lit { value: Box::new(AnyAtom::Int(i.clone())) },
+        Value::String(s) => Pattern::Lit { value: Box::new(AnyAtom::String(s.clone())) },
+        Value::ByteString(bs) => Pattern::Lit { value: Box::new(AnyAtom::Bytes(bs.clone())) },
+        Value::Symbol(s) => Pattern::Lit { value: Box::new(AnyAtom::Symbol(s.clone())) },
+        Value::Record(r) => Pattern::Group {
+            type_: Box::new(GroupType::Rec { label: r.label().clone() }),
+            entries: r.fields().iter().enumerate()
+                .map(|(i, v)| (N::new(i), lift_literal(v)))
+                .collect(),
+        },
+        Value::Sequence(items) => Pattern::Group {
+            type_: Box::new(GroupType::Arr),
+            entries: items.iter().enumerate()
+                .map(|(i, v)| (N::new(i), lift_literal(v)))
+                .collect(),
+        },
+        Value::Set(_members) => panic!("Cannot express literal set in pattern"),
+        Value::Dictionary(entries) => Pattern::Group {
+            type_: Box::new(GroupType::Dict),
+            entries: entries.iter()
+                .map(|(k, v)| (k.clone(), lift_literal(v)))
+                .collect(),
+        },
+        Value::Embedded(e) => Pattern::Lit { value: Box::new(AnyAtom::Embedded(e.clone())) },
+    }
+}
diff --git a/syndicate-schema-plugin/src/pattern_plugin.rs b/syndicate-schema-plugin/src/pattern_plugin.rs
index 355e12d..9412e2c 100644
--- a/syndicate-schema-plugin/src/pattern_plugin.rs
+++ b/syndicate-schema-plugin/src/pattern_plugin.rs
@@ -7,16 +7,27 @@ use preserves_schema::gen::schema::*;
 use preserves_schema::syntax::block::escape_string;
 use preserves_schema::syntax::block::constructors::*;
 
+use preserves::value::IOValue;
+use preserves::value::Map;
+use preserves::value::NestedValue;
+
 use std::iter::FromIterator;
 
-use syndicate::pattern::lift_literal;
-use syndicate::schemas::dataspace_patterns as P;
-use syndicate::value::IOValue;
-use syndicate::value::Map;
-use syndicate::value::NestedValue;
+use crate::pattern::lift_literal;
+use crate::schemas::dataspace_patterns as P;
 
 #[derive(Debug)]
-pub struct PatternPlugin;
+pub struct PatternPlugin {
+    pub syndicate_crate: String,
+}
+
+impl PatternPlugin {
+    pub fn new() -> Self {
+        PatternPlugin {
+            syndicate_crate: "syndicate".to_string(),
+        }
+    }
+}
 
 type WalkState<'a, 'm, 'b> =
     preserves_schema::compiler::cycles::WalkState<&'a ModuleContext<'m, 'b>>;
@@ -35,7 +46,7 @@ impl Plugin for PatternPlugin {
                                          Purpose::Codegen,
                                          definition_name,
                                          definition);
-                let v = syndicate::language().unparse(&p);
+                let v = crate::language().unparse(&p);
                 let v = preserves_schema::support::preserves::value::TextWriter::encode(
                     &mut preserves_schema::support::preserves::value::NoEmbeddedDomainCodec,
                     &v).unwrap();
@@ -47,14 +58,15 @@ impl Plugin for PatternPlugin {
                     ty.generic_arg(ctxt),
                     " ", codeblock![
                         seq!["#[allow(unused)] pub fn wildcard_dataspace_pattern() ",
-                             "-> syndicate::schemas::dataspace_patterns::Pattern ",
+                             seq!["-> ", self.syndicate_crate.clone(), "::schemas::dataspace_patterns::Pattern "],
                              codeblock![
-                                 "use syndicate::schemas::dataspace_patterns::*;",
+                                 seq!["use ", self.syndicate_crate.clone(), "::schemas::dataspace_patterns::*;"],
                                  "use preserves_schema::Codec;",
-                                 seq!["let _v = syndicate::value::text::from_str(",
+                                 seq!["let _v = ", self.syndicate_crate.clone(), "::value::text::from_str(",
                                       escape_string(&v),
-                                      ", syndicate::value::ViaCodec::new(syndicate::value::NoEmbeddedDomainCodec)).unwrap();"],
-                                 "syndicate::language().parse(&_v).unwrap()"]]]]));
+                                      ", ", self.syndicate_crate.clone(), "::value::ViaCodec::new(",
+                                      self.syndicate_crate.clone(), "::value::NoEmbeddedDomainCodec)).unwrap();"],
+                                 seq![self.syndicate_crate.clone(), "::language().parse(&_v).unwrap()"]]]]]));
             }
         }
     }
diff --git a/syndicate-server/build.rs b/syndicate-server/build.rs
index 7c6e575..037dde4 100644
--- a/syndicate-server/build.rs
+++ b/syndicate-server/build.rs
@@ -7,7 +7,7 @@ fn main() -> std::io::Result<()> {
     gen_dir.push("src/schemas");
 
     let mut c = CompilerConfig::new("crate::schemas".to_owned());
-    c.plugins.push(Box::new(syndicate_schema_plugin::PatternPlugin));
+    c.plugins.push(Box::new(syndicate_schema_plugin::PatternPlugin::new()));
     c.add_external_module(ExternalModule::new(vec!["EntityRef".to_owned()], "syndicate::actor"));
     c.add_external_module(
         ExternalModule::new(vec!["TransportAddress".to_owned()],
diff --git a/syndicate/Cargo.toml b/syndicate/Cargo.toml
index 8a5eee9..730bb8d 100644
--- a/syndicate/Cargo.toml
+++ b/syndicate/Cargo.toml
@@ -14,6 +14,7 @@ vendored-openssl = ["openssl/vendored"]
 
 [build-dependencies]
 preserves-schema = "5.995"
+syndicate-schema-plugin = { path = "../syndicate-schema-plugin", version = "0.9.0"}
 
 [dependencies]
 preserves = "4.995"
diff --git a/syndicate/build.rs b/syndicate/build.rs
index 9a8daf1..a6c2cdb 100644
--- a/syndicate/build.rs
+++ b/syndicate/build.rs
@@ -1,25 +1,5 @@
 use preserves_schema::compiler::*;
 
-mod syndicate_plugins {
-    use preserves_schema::compiler::*;
-    use preserves_schema::gen::schema::*;
-    // use preserves_schema::syntax::block::constructors::*;
-
-    #[derive(Debug)]
-    pub(super) struct PatternPlugin;
-
-    impl Plugin for PatternPlugin {
-        fn generate_definition(
-            &self,
-            _m: &mut context::ModuleContext,
-            _definition_name: &str,
-            _definition: &Definition,
-        ) {
-            // TODO: Emit code for building instances of sturdy.Pattern and sturdy.Template
-        }
-    }
-}
-
 fn main() -> std::io::Result<()> {
     let buildroot = std::path::PathBuf::from(std::env::var_os("OUT_DIR").unwrap());
 
@@ -27,7 +7,9 @@ fn main() -> std::io::Result<()> {
     gen_dir.push("src/schemas");
 
     let mut c = CompilerConfig::new("crate::schemas".to_owned());
-    c.plugins.push(Box::new(syndicate_plugins::PatternPlugin));
+    c.plugins.push(Box::new(syndicate_schema_plugin::PatternPlugin {
+        syndicate_crate: "crate".to_string(),
+    }));
     c.add_external_module(ExternalModule::new(vec!["EntityRef".to_owned()], "crate::actor"));
 
     let inputs = expand_inputs(&vec!["protocols/schema-bundle.bin".to_owned()])?;