@adeficior/data-modifier-recipes 2.0.0-rc.20260814115618

package/dist/serializer/vanilla/smithing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"smithing.js","sourceRoot":"","sources":["../../../src/serializer/vanilla/smithing.ts"],"names":[],"mappings":"AAAA,OAAO,EAGN,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,EAAyB,MAAM,cAAc,CAAC;AACrD,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAA2B,MAAM,YAAY,CAAC;AACrD,OAAO,EAAuB,MAAM,aAAa,CAAC;AAUlD,MAAM,OAAO,cAAe,SAAQ,MAAM;IAErB;IACA;IACA;IACA;IAJnB,YACmB,IAAgB,EAChB,QAAoB,EACpB,MAA0B,EAC1B,QAAgC;QAEjD,KAAK,EAAE,CAAC;QALS,SAAI,GAAJ,IAAI,CAAY;QAChB,aAAQ,GAAR,QAAQ,CAAY;QACpB,WAAM,GAAN,MAAM,CAAoB;QAC1B,aAAQ,GAAR,QAAQ,CAAwB;IAGnD,CAAC;IAED,cAAc;QACZ,OAAO,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IACnE,CAAC;IAED,UAAU;QACR,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IACvC,CAAC;IAEQ,MAAM,CAAC,QAAwB;QACtC,OAAO,IAAI,cAAc,CACvB,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,EAC9B,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,EAClC,IAAI,CAAC,MAAM,IAAI,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,EAC3C,IAAI,CAAC,QAAQ,IAAI,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,CACpD,CAAC;IACJ,CAAC;IAEQ,SAAS,CAChB,OAA2B;QAE3B,OAAO;YACL,IAAI,EAAE,OAAO,CAAC,WAAW,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC;YAC9C,QAAQ,EAAE,OAAO,CAAC,WAAW,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC;YACtD,MAAM,EAAE,OAAO,CAAC,OAAO,CAAC,iBAAiB,CAAC,IAAI,CAAC,MAAM,CAAC;YACtD,QAAQ,EAAE,OAAO,CAAC,WAAW,CAAC,iBAAiB,CAAC,IAAI,CAAC,QAAQ,CAAC;SAC/D,CAAC;IACJ,CAAC;CACF;AAED,MAAM,OAAO,cAAe,SAAQ,YAGnC;IACC,WAAW,CACT,UAAoC,EACpC,OAA2B;QAE3B,MAAM,IAAI,GAAG,OAAO,CAAC,WAAW,CAAC,WAAW,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QAC9D,MAAM,QAAQ,GAAG,OAAO,CAAC,WAAW,CAAC,WAAW,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;QACtE,MAAM,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,mBAAmB,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QACtE,MAAM,QAAQ,GAAG,OAAO,CAAC,WAAW,CAAC,mBAAmB,CACtD,UAAU,CAAC,QAAQ,CACpB,CAAC;QACF,OAAO,IAAI,cAAc,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;IAC9D,CAAC;CACF"}

package/dist/serializer/vanilla/stonecutting.d.ts

@@ -0,0 +1,22 @@
+import { type Ingredient, type Result } from "@adeficior/data-modifier-ingredients";
+import { type RecipeDefinition } from "../../schema";
+import { Recipe, RecipeParser } from "../abstract";
+import { type RecipeParseContext } from "../context";
+import { type RecipeModifier } from "../modifier";
+export type StonecuttingRecipeDefinition = RecipeDefinition & Readonly<{
+    ingredient: unknown;
+    result: unknown;
+    count?: number;
+}>;
+export declare class StonecuttingRecipe extends Recipe {
+    private readonly ingredient;
+    private readonly result;
+    constructor(ingredient: Ingredient, result: Result);
+    getIngredients(): Ingredient[];
+    getResults(): Result[];
+    modify(modifier: RecipeModifier): StonecuttingRecipe;
+    serialize(context: RecipeParseContext): Partial<StonecuttingRecipeDefinition>;
+}
+export declare class StonecuttingParser extends RecipeParser<StonecuttingRecipeDefinition, StonecuttingRecipe> {
+    deserialize(definition: StonecuttingRecipeDefinition, context: RecipeParseContext): StonecuttingRecipe;
+}

package/dist/serializer/vanilla/stonecutting.js

@@ -0,0 +1,38 @@
+import {} from "@adeficior/data-modifier-ingredients";
+import {} from "../../schema";
+import { Recipe, RecipeParser } from "../abstract";
+import {} from "../context";
+import {} from "../modifier";
+// TODO could also be SmeltingRecipe?
+export class StonecuttingRecipe extends Recipe {
+    ingredient;
+    result;
+    constructor(ingredient, result) {
+        super();
+        this.ingredient = ingredient;
+        this.result = result;
+    }
+    getIngredients() {
+        return [this.ingredient];
+    }
+    getResults() {
+        return [this.result];
+    }
+    modify(modifier) {
+        return new StonecuttingRecipe(modifier.ingredient(this.ingredient), modifier.result(this.result));
+    }
+    serialize(context) {
+        return {
+            ingredient: context.ingredients.serialize(this.ingredient),
+            result: context.results.serialize(this.result),
+        };
+    }
+}
+export class StonecuttingParser extends RecipeParser {
+    deserialize(definition, context) {
+        const ingredient = context.ingredients.deserialize(definition.ingredient);
+        const result = context.results.deserialize(definition.result);
+        return new StonecuttingRecipe(ingredient, result);
+    }
+}
+//# sourceMappingURL=stonecutting.js.map

package/dist/serializer/vanilla/stonecutting.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stonecutting.js","sourceRoot":"","sources":["../../../src/serializer/vanilla/stonecutting.ts"],"names":[],"mappings":"AAAA,OAAO,EAGN,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAAyB,MAAM,cAAc,CAAC;AACrD,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAA2B,MAAM,YAAY,CAAC;AACrD,OAAO,EAAuB,MAAM,aAAa,CAAC;AASlD,qCAAqC;AACrC,MAAM,OAAO,kBAAmB,SAAQ,MAAM;IAEzB;IACA;IAFnB,YACmB,UAAsB,EACtB,MAAc;QAE/B,KAAK,EAAE,CAAC;QAHS,eAAU,GAAV,UAAU,CAAY;QACtB,WAAM,GAAN,MAAM,CAAQ;IAGjC,CAAC;IAED,cAAc;QACZ,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IAC3B,CAAC;IAED,UAAU;QACR,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACvB,CAAC;IAEQ,MAAM,CAAC,QAAwB;QACtC,OAAO,IAAI,kBAAkB,CAC3B,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,EACpC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAC7B,CAAC;IACJ,CAAC;IAEQ,SAAS,CAChB,OAA2B;QAE3B,OAAO;YACL,UAAU,EAAE,OAAO,CAAC,WAAW,CAAC,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC;YAC1D,MAAM,EAAE,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC;SAC/C,CAAC;IACJ,CAAC;CACF;AAED,MAAM,OAAO,kBAAmB,SAAQ,YAGvC;IACC,WAAW,CACT,UAAwC,EACxC,OAA2B;QAE3B,MAAM,UAAU,GAAG,OAAO,CAAC,WAAW,CAAC,WAAW,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC;QAC1E,MAAM,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QAC9D,OAAO,IAAI,kBAAkB,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;IACpD,CAAC;CACF"}

package/eslint.config.js

@@ -0,0 +1,8 @@
+//@ts-check
+import { eslintConfig } from "@adeficior/configs/eslint";
+import { defineConfig, globalIgnores } from "eslint/config";
+
+export default defineConfig([
+  globalIgnores(["test/resources/**"]),
+  eslintConfig(import.meta.dirname),
+]);

package/package.json

@@ -0,0 +1,42 @@
+{
+   "name": "@adeficior/data-modifier-recipes",
+   "version": "2.0.0-rc.20260814115618",
+   "exports": {
+      ".": "./dist/index.js",
+      "./testing": "./dist/testing/index.js"
+   },
+   "types": "./dist/index.d.ts",
+   "typesVersions": {
+      "*": {
+         "testing": [
+            "./dist/testing/index.d.ts"
+         ]
+      }
+   },
+   "type": "module",
+   "scripts": {
+      "build": "tsc --project tsconfig.build.json",
+      "check": "tsc --noEmit",
+      "dev": "bun run build --watch",
+      "lint": "eslint {src,test}",
+      "test": "bun test --timeout 10000",
+      "prune": "bun run datamod-dev --prune",
+      "prepare": "datamod-dev --configs && datamod-dev --types",
+      "test:ci": "bun run lint && bun run check && bun run test --coverage"
+   },
+   "devDependencies": {
+      "@adeficior/configs": "workspace:*",
+      "@adeficior/testing": "workspace:*",
+      "@types/lodash-es": "catalog:",
+      "@adeficior/data-modifier-ingredients": "workspace:*"
+   },
+   "peerDependencies": {
+      "@adeficior/pack-resolver": "catalog:",
+      "typescript": "catalog:",
+      "minimatch": "catalog:",
+      "lodash-es": "catalog:",
+      "@adeficior/data-modifier-core": "workspace:*",
+      "@adeficior/data-modifier-ingredients": "workspace:*",
+      "@adeficior/data-modifier-tags": "workspace:*"
+   }
+}

package/src/emitter.ts

@@ -0,0 +1,239 @@
+import {
+  CustomEmitter,
+  encodeId,
+  RuledEmitter,
+  withDisabledConditions,
+  type ClearableEmitter,
+  type Id,
+  type IdInput,
+  type LoaderContext,
+  type Modifier,
+  type NormalizedId,
+  type RegistryProvider,
+  type SemVerInput,
+} from "@adeficior/data-modifier-core";
+import {
+  createReplacer,
+  resolveIdTest,
+  type CommonFilter,
+  type Predicate,
+} from "@adeficior/data-modifier-core/serializer";
+import {
+  type Ingredient,
+  type IngredientFilter,
+  type IngredientInput,
+  type IngredientSerializer,
+  type Predicates,
+  type Result,
+  type ResultInput,
+  type ResultSerializer,
+} from "@adeficior/data-modifier-ingredients";
+import { type RecipeSerializerId } from "@adeficior/data-modifier/generated";
+import {
+  combineResolvers,
+  notNull,
+  type ContextLike,
+  type Logger,
+} from "@adeficior/pack-resolver";
+import { RecipeRule } from "./rule";
+import { recipePath, type RecipeDefinition } from "./schema";
+import { type Recipe } from "./serializer/abstract";
+import { type RecipeSerializer } from "./serializer/context";
+import { RecipeHolder } from "./serializer/holder";
+
+export type RecipeTest = Readonly<{
+  id?: CommonFilter<NormalizedId>;
+  type?: CommonFilter<NormalizedId<RecipeSerializerId>>;
+  namespace?: string;
+  output?: IngredientFilter;
+  input?: IngredientFilter;
+  // TODO not sure if I want to even keep this?
+  optional?: boolean;
+}>;
+
+export interface RecipeRules {
+  replaceResult(
+    test: IngredientFilter,
+    value: ResultInput,
+    additionalTests?: RecipeTest,
+  ): void;
+
+  replaceIngredient(
+    test: IngredientFilter,
+    value: IngredientInput,
+    additionalTests?: RecipeTest,
+  ): void;
+
+  add(id: IdInput, value: RecipeDefinition): void;
+  add(id: IdInput, value: RecipeHolder): void;
+  add(id: IdInput, type: NormalizedId<RecipeSerializerId>, value: Recipe): void;
+
+  remove(test: RecipeTest): void;
+}
+
+export const EMPTY_RECIPE: RecipeDefinition = withDisabledConditions({
+  type: "minecraft:disabled",
+});
+
+export class RecipeEmitter implements RecipeRules, ClearableEmitter {
+  private readonly custom = new CustomEmitter<RecipeDefinition>((it) =>
+    recipePath(this.packFormat, it),
+  );
+
+  private readonly ruled: RuledEmitter<RecipeHolder, RecipeRule>;
+
+  constructor(
+    // TODO inject
+    private readonly logger: Logger,
+    private readonly packFormat: SemVerInput,
+    private readonly registry: RegistryProvider<RecipeHolder>,
+    private readonly resultSerializer: ResultSerializer,
+    private readonly ingredientSerializer: IngredientSerializer,
+    private readonly predicates: Predicates,
+    private readonly serializer: RecipeSerializer,
+  ) {
+    this.ruled = new RuledEmitter<RecipeHolder, RecipeRule>(
+      this.registry,
+      (id) => recipePath(packFormat, id),
+      EMPTY_RECIPE,
+      (it) => this.serializer.serialize(it),
+      (id) => this.custom.has(id),
+    );
+  }
+
+  resolver(context: LoaderContext) {
+    return combineResolvers(
+      [this.ruled.resolver(context), this.custom.resolver(context)],
+      { async: true },
+    );
+  }
+
+  private createIngredientPredicate(filter?: IngredientFilter) {
+    if (!filter) return () => true;
+    return this.predicates.ingredient(filter);
+  }
+
+  private createResultPredicate(filter?: IngredientFilter) {
+    if (!filter) return () => true;
+    return this.predicates.result(filter);
+  }
+
+  private resolveRecipeTest(test: RecipeTest) {
+    const id: Predicate<Id>[] = [];
+    const type: Predicate<Id>[] = [];
+    const ingredient: Predicate<Ingredient>[] = [];
+    const result: Predicate<Result>[] = [];
+
+    if (test.id) id.push(resolveIdTest(test.id));
+    if (test.type) type.push(resolveIdTest(test.type));
+    if (test.namespace) id.push((id) => id.namespace === test.namespace);
+    if (test.output) result.push(this.createResultPredicate(test.output));
+    if (test.input) ingredient.push(this.createIngredientPredicate(test.input));
+
+    return { id, type, ingredient, result };
+  }
+
+  add(
+    id: IdInput,
+    arg: RecipeDefinition | RecipeHolder | NormalizedId<RecipeSerializerId>,
+    arg2?: Recipe,
+  ) {
+    if (typeof arg === "string") {
+      const type = arg;
+      const recipe = arg2!;
+      this.add(id, new RecipeHolder({ type }, recipe));
+    } else {
+      const value = arg;
+
+      if (this.custom.has(id))
+        this.logger.error(`Overwriting custom recipe with ID ${encodeId(id)}`);
+
+      if (value instanceof RecipeHolder)
+        this.custom.add(id, this.serializer.serialize(value));
+      else this.custom.add(id, value);
+    }
+  }
+
+  private addRule(
+    context: ContextLike,
+    modifier: Modifier<RecipeHolder>,
+    recipeTest: RecipeTest = {},
+    ingredientTests: {
+      ingredient?: Predicate<Ingredient>;
+      result?: Predicate<Result>;
+    } = {},
+  ) {
+    const recipePredicates = this.resolveRecipeTest(recipeTest ?? {});
+
+    this.ruled.addRule(
+      new RecipeRule(
+        context,
+        recipePredicates.id,
+        recipePredicates.type,
+        [ingredientTests.ingredient, ...recipePredicates.ingredient].filter(
+          notNull,
+        ),
+        [ingredientTests.result, ...recipePredicates.result].filter(notNull),
+        modifier,
+      ),
+      recipeTest.optional !== true,
+    );
+  }
+
+  remove(test: RecipeTest) {
+    this.addRule({ operation: "remove", test }, () => null, test);
+  }
+
+  replaceResult(
+    test: IngredientFilter,
+    input: ResultInput,
+    additionalTest?: RecipeTest,
+  ) {
+    const predicate = this.createResultPredicate(test);
+
+    const value = this.resultSerializer.deserialize(input);
+
+    const replace = createReplacer(predicate, value);
+
+    this.addRule(
+      {
+        operation: "replace result",
+        from: test,
+        to: value,
+        test: additionalTest,
+      },
+      (recipe) => recipe.replaceResult(replace),
+      additionalTest,
+      { result: predicate },
+    );
+  }
+
+  replaceIngredient(
+    test: IngredientFilter,
+    input: IngredientInput,
+    additionalTest?: RecipeTest,
+  ) {
+    const predicate = this.createIngredientPredicate(test);
+
+    const value = this.ingredientSerializer.deserialize(input);
+
+    const replace = createReplacer(predicate, value);
+
+    this.addRule(
+      {
+        operation: "replace ingredient",
+        from: test,
+        to: value,
+        test: additionalTest,
+      },
+      (recipe) => recipe.replaceIngredient(replace),
+      additionalTest,
+      { ingredient: predicate },
+    );
+  }
+
+  clear() {
+    this.custom.clear();
+    this.ruled.clear();
+  }
+}

package/src/hooks.ts

@@ -0,0 +1,10 @@
+import { type RecipeSerializerId } from "@adeficior/data-modifier/generated";
+import { type RecipeDefinition } from "./schema";
+import { type Recipe, type RecipeParser } from "./serializer/abstract";
+
+export type RegisterRecipeParser = {
+  register(
+    recipeType: RecipeSerializerId,
+    parser: RecipeParser<RecipeDefinition, Recipe>,
+  ): void;
+};

package/src/index.ts

@@ -0,0 +1,18 @@
+export { EMPTY_RECIPE, type RecipeRules, type RecipeTest } from "./emitter";
+export type * from "./hooks";
+export type { RecipeLoaderAccessor } from "./loader";
+export { default } from "./module";
+export * from "./schema";
+export * from "./serializer/abstract";
+export type * from "./serializer/context";
+export * from "./serializer/forge/conditional";
+export type * from "./serializer/holder";
+export * from "./serializer/manyToMany";
+export * from "./serializer/manyToOne";
+export type * from "./serializer/modifier";
+export * from "./serializer/oneToOne";
+export * from "./serializer/vanilla/shaped";
+export * from "./serializer/vanilla/shapeless";
+export * from "./serializer/vanilla/smelting";
+export * from "./serializer/vanilla/smithing";
+export * from "./serializer/vanilla/stonecutting";

package/src/loader.ts

@@ -0,0 +1,219 @@
+import {
+  encodeId,
+  IllegalShapeError,
+  JsonLoader,
+  type ConditionContext,
+  type RegistryProvider,
+} from "@adeficior/data-modifier-core";
+import {
+  type IngredientSerializer,
+  type ResultSerializer,
+  type WithSerializerModules,
+} from "@adeficior/data-modifier-ingredients";
+import { omit } from "lodash-es";
+import { minimatch } from "minimatch";
+import { type RecipeDefinition } from "./schema";
+import { type Recipe, type RecipeParser } from "./serializer/abstract";
+import {
+  type RecipeParseContext,
+  type RecipeSerializer,
+} from "./serializer/context";
+import { ForgeConditionalRecipeParser } from "./serializer/forge/conditional";
+import { RecipeHolder } from "./serializer/holder";
+import { ShapedParser } from "./serializer/vanilla/shaped";
+import { ShapelessParser } from "./serializer/vanilla/shapeless";
+import { SmeltingParser } from "./serializer/vanilla/smelting";
+import { SmithingParser } from "./serializer/vanilla/smithing";
+import { StonecuttingParser } from "./serializer/vanilla/stonecutting";
+
+export interface RecipeLoaderAccessor extends RegistryProvider<RecipeHolder> {
+  unknownRecipeTypes(): RecipeDefinition[];
+  registerParser(
+    recipeType: string,
+    parser: RecipeParser<RecipeDefinition, Recipe>,
+  ): void;
+  ignoreType(recipeType: string): void;
+}
+
+// Split serializer into seperate class
+export class RecipeLoader
+  extends JsonLoader<RecipeHolder>
+  implements RecipeLoaderAccessor, RecipeSerializer
+{
+  private readonly recipeParsers = new Map<string, RecipeParser>();
+
+  private readonly ignoredRecipeTypePatterns: string[] = [];
+  private readonly _unknownRecipeTypes = new Map<string, RecipeDefinition>();
+
+  constructor(
+    private readonly resultSerializer: ResultSerializer,
+    private readonly ingredientSerializer: IngredientSerializer,
+    context?: ConditionContext,
+  ) {
+    super(context);
+
+    this.registerParser("minecraft:crafting_shaped", new ShapedParser());
+    this.registerParser("minecraft:crafting_shapeless", new ShapelessParser());
+    this.registerParser("minecraft:smelting", new SmeltingParser());
+    this.registerParser("minecraft:smoking", new SmeltingParser());
+    this.registerParser("minecraft:blasting", new SmeltingParser());
+    this.registerParser("minecraft:campfire_cooking", new SmeltingParser());
+    this.registerParser("minecraft:smithing", new SmithingParser());
+    this.registerParser("minecraft:smithing_trim", new SmithingParser());
+    this.registerParser("minecraft:smithing_transform", new SmithingParser());
+    this.registerParser("minecraft:stonecutting", new StonecuttingParser());
+
+    this.registerParser("theoneprobe:probe_helmet", new ShapedParser());
+
+    this.registerParser(
+      "forge:conditional",
+      new ForgeConditionalRecipeParser(),
+    );
+    /*
+    TODO move to seperate modules
+
+    this.registerParser(
+      "sullysmod:grindstone_polishing",
+      new GrindstonePolishingParser(),
+    );
+
+    this.registerParser("ad_astra:hammering", new HammeringRecipeParser());
+    this.registerParser(
+      "ad_astra:cryo_fuel_conversion",
+      new FluidConversionRecipeParser(),
+    );
+    this.registerParser(
+      "ad_astra:fuel_conversion",
+      new FluidConversionRecipeParser(),
+    );
+    this.registerParser(
+      "ad_astra:oxygen_conversion",
+      new FluidConversionRecipeParser(),
+    );
+    this.registerParser("ad_astra:compressing", new InputOutputRecipeParser());
+    this.registerParser(
+      "ad_astra:crafting_shaped_space_suit",
+      new ShapedParser(),
+    );
+    this.registerParser(
+      "ad_astra:nasa_workbench",
+      new NasaWorkbenchRecipeParser(),
+    );
+    this.registerParser(
+      "ad_astra:space_station",
+      new SpaceStationRecipeParser(),
+    );
+
+    this.registerParser(
+      "patchouli:shapeless_book_recipe",
+      new ShapelessParser(),
+    );
+
+    this.registerParser("cofh_core:crafting_shaped_potion", new ShapedParser());
+
+    this.registerParser(
+      "rootsclassic:component",
+      new RootComponentRecipeParser(),
+    );
+    this.registerParser("rootsclassic:ritual", new RootRitualRecipeParser());
+
+    this.ignoreType("jeed:*");
+    this.ignoreType("immersiveengineering:*");
+    */
+  }
+
+  ignoreType(pattern: string) {
+    this.ignoredRecipeTypePatterns.push(pattern);
+  }
+
+  unknownRecipeTypes() {
+    return [...this._unknownRecipeTypes.values()];
+  }
+
+  private recipeParseContext(
+    parser: WithSerializerModules,
+  ): RecipeParseContext {
+    return {
+      recipes: this,
+      ingredients: this.ingredientSerializer.selectModule(
+        parser.ingredientModules(),
+      ),
+      results: this.resultSerializer.selectModule(parser.resultModules()),
+    };
+  }
+
+  serialize(recipe: RecipeHolder): RecipeDefinition {
+    const parser = this.recipeParsers.get(recipe.serializerType);
+
+    if (!parser)
+      throw new Error(
+        `Unable to find parser for type '${recipe.serializerType}'`,
+      );
+
+    const context = this.recipeParseContext(parser);
+    return recipe.serialize(context);
+  }
+
+  deserialize(definition: RecipeDefinition): RecipeHolder {
+    if (!definition.type)
+      throw new IllegalShapeError(`no recipe type set`, definition);
+
+    const parser = this.recipeParsers.get(encodeId(definition.type));
+
+    if (!("type" in definition))
+      throw new IllegalShapeError("recipe type missing");
+
+    if (!parser) {
+      if (!this._unknownRecipeTypes.has(definition.type)) {
+        this._unknownRecipeTypes.set(definition.type, definition);
+      }
+
+      throw new IllegalShapeError(
+        `unknown recipe type: '${definition.type}'`,
+        definition,
+      );
+    }
+
+    const parsed = parser.deserialize(
+      definition,
+      this.recipeParseContext(parser),
+    );
+
+    return new RecipeHolder(definition, parsed);
+  }
+
+  override parse(definition: RecipeDefinition): RecipeHolder | null {
+    if (
+      this.ignoredRecipeTypePatterns.some((it) =>
+        minimatch(definition.type, it),
+      )
+    )
+      return null;
+
+    // TODO only print unknown recipe types once in the end
+
+    const importantData = omit(
+      definition,
+      "type",
+      "category",
+      "conditions",
+      "fabric:load_conditions",
+      "neoforge:conditions",
+    );
+
+    if (Object.keys(importantData).length === 0) return null;
+
+    return this.deserialize(definition);
+  }
+
+  registerParser(
+    recipeType: string,
+    parser: RecipeParser<RecipeDefinition, Recipe>,
+  ) {
+    this.recipeParsers.set(recipeType, parser);
+  }
+
+  clear() {
+    this._unknownRecipeTypes.clear();
+  }
+}

package/src/module.ts

@@ -0,0 +1,70 @@
+import { defineModule } from "@adeficior/data-modifier-core";
+import { name } from "../package.json";
+import { RecipeEmitter, type RecipeRules } from "./emitter";
+import { type RegisterRecipeParser } from "./hooks";
+import { RecipeLoader, type RecipeLoaderAccessor } from "./loader";
+import { recipePattern } from "./schema";
+
+export default defineModule<{
+  hooks: {
+    "recipes:register-parser": RegisterRecipeParser;
+  };
+  emitters: {
+    recipes: RecipeRules;
+  };
+  loaders: {
+    recipes: RecipeLoaderAccessor;
+  };
+}>({
+  importModule: name,
+  dependencies: {
+    "@adeficior/data-modifier-ingredients": "required",
+    // TODO make optional?
+    "@adeficior/data-modifier-tags": "required",
+  },
+  types: {
+    hooks: {
+      "recipes:register-parser": { name: "RegisterRecipeParser" },
+    },
+    loaders: {
+      recipes: "RecipeLoaderAccessor",
+    },
+    emitters: {
+      recipes: "RecipeRules",
+    },
+  },
+  setup: (pack) => {
+    const loader = pack.loader(
+      "recipes",
+      (container) =>
+        new RecipeLoader(
+          container.get("serializer:results"),
+          container.get("serializer:ingredients"),
+        ),
+      recipePattern(pack.options.packFormat),
+    );
+
+    pack.emitter(
+      "recipes",
+      (container) =>
+        new RecipeEmitter(
+          container.get("logger"),
+          pack.options.packFormat,
+          loader(),
+          container.get("serializer:results"),
+          container.get("serializer:ingredients"),
+          container.get("predicates"),
+          loader(),
+        ),
+    );
+
+    pack.hook("setup:after", ({ callHook }) => {
+      const serializer = loader();
+      callHook("recipes:register-parser", {
+        register: (type, parser) => {
+          serializer.registerParser(type, parser);
+        },
+      });
+    });
+  },
+});