@terrafirmagreg-team/recipe 0.1.0 → 1.2.1

package/src/lib/calc/tree/tree.test.ts

@@ -1,169 +0,0 @@
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-import type {
-  CalcRecipe,
-  CalcRecipeInput,
-  CalcRecipeSummary,
-  CalcMaterial,
-} from '@terrafirmagreg-team/recipe/types/calc';
-import type { RecipeCompactRow } from '@terrafirmagreg-team/recipe/types';
-import type { BuildContext } from './context';
-import { buildGoal } from './goal';
-import { idealBatchMultiplier } from './ideal';
-
-const input = (
-  id: string,
-  amount: number,
-  extra?: Partial<CalcRecipeInput>,
-): CalcRecipeInput => ({
-  id,
-  kind: 'item',
-  amount,
-  catalyst: false,
-  ...extra,
-});
-
-const output = (id: string, amount: number, chance?: number): CalcMaterial => ({
-  id,
-  kind: 'item',
-  amount,
-  ...(chance !== undefined ? { chance } : {}),
-});
-
-const recipe = (
-  recipeId: string,
-  inputs: CalcRecipeInput[],
-  outputs: CalcMaterial[],
-): CalcRecipe => ({ recipeId, category: 'test', inputs, outputs });
-
-const summary = (
-  recipe: CalcRecipe,
-): CalcRecipeSummary => ({
-  recipeId: recipe.recipeId,
-  category: 'test',
-  outputAmount: recipe.outputs[0]?.amount ?? 1,
-  row: {
-    id: recipe.recipeId,
-    type: 0,
-    in: recipe.inputs.map((row) => row.id),
-    out: recipe.outputs.map((row) => row.id),
-  } satisfies RecipeCompactRow,
-});
-
-const ctx = (
-  recipes: CalcRecipe[],
-): Omit<BuildContext, 'pool' | 'used' | 'usedMaterials'> => {
-  const outs = new Map<string, CalcRecipeSummary[]>();
-  for (const r of recipes) {
-    for (const out of r.outputs) {
-      const key = `${out.kind}:${out.id}`;
-      outs.set(key, [...(outs.get(key) ?? []), summary(r)]);
-    }
-  }
-  return {
-    recipeMap: new Map(recipes.map((r) => [r.recipeId, r])),
-    getRecipesForItem: (id, kind) => outs.get(`${kind}:${id}`) ?? [],
-    selections: {},
-    tagSelections: {},
-    tagMembers: () => undefined,
-
-    autoRoots: ['g0'],
-  };
-};
-
-const stock = (id: string, amount: number): CalcMaterial => ({
-  id,
-  kind: 'item',
-  amount,
-});
-
-test('inventory seeds the pool and covers the goal demand first', () => {
-
-  const r = recipe('r1', [input('a', 1)], [output('t', 1)]);
-  const goal = buildGoal(
-    { id: 't', kind: 'item', amount: 2 },
-    ctx([r]),
-    'g0',
-    [stock('a', 2)],
-  );
-  const child = goal.node.children[0]!;
-  assert.equal(goal.node.need, 2);
-  assert.equal(goal.node.batches, 2);
-  assert.equal(child.satisfied, 2);
-  assert.equal(child.need, 0);
-});
-
-test('goal demand eats inventory directly when the pool holds the target', () => {
-  const goal = buildGoal(
-    { id: 't', kind: 'item', amount: 5 },
-    ctx([]),
-    'g0',
-    [stock('t', 2)],
-  );
-  assert.equal(goal.node.satisfied, 2);
-  assert.equal(goal.node.need, 3);
-});
-
-test('consume chance scales the expected child demand', () => {
-
-  const r = recipe(
-    'r1',
-    [input('a', 2, { chance: 0.5 })],
-    [output('t', 1)],
-  );
-  const goal = buildGoal(
-    { id: 't', kind: 'item', amount: 1 },
-    ctx([r]),
-    'g0',
-  );
-  const child = goal.node.children[0]!;
-  assert.equal(child.amount, 1);
-  assert.equal(child.consumeChance, 0.5);
-});
-
-test('chance-weighted secondary outputs feed the remainder pool', () => {
-
-  const r = recipe(
-    'r1',
-    [input('a', 1)],
-    [output('t', 1), output('s', 1, 0.25)],
-  );
-  const goal = buildGoal(
-    { id: 't', kind: 'item', amount: 2 },
-    ctx([r]),
-    'g0',
-  );
-  const side = goal.remainders.find((row) => row.id === 's');
-  assert.ok(side);
-  assert.equal(side.amount, 0.5);
-});
-
-test('ideal batch is the LCM of divisibility constraints', () => {
-
-  const ore = recipe('ore', [input('rock', 1)], [output('ingot', 2)]);
-  const plate = recipe('plate', [input('ingot', 3)], [output('plate', 1)]);
-  const goal = buildGoal(
-    { id: 'plate', kind: 'item', amount: 1 },
-    ctx([ore, plate]),
-    'g0',
-  );
-  assert.equal(idealBatchMultiplier(goal.node), 2);
-});
-
-test('ideal batch uses the post-pool need, not the raw demand', () => {
-
-  const r = recipe('r1', [input('a', 1)], [output('t', 2)]);
-  const withStock = buildGoal(
-    { id: 't', kind: 'item', amount: 3 },
-    ctx([r]),
-    'g0',
-    [stock('t', 1)],
-  );
-  assert.equal(idealBatchMultiplier(withStock.node), 1);
-  const bare = buildGoal(
-    { id: 't', kind: 'item', amount: 3 },
-    ctx([r]),
-    'g0',
-  );
-  assert.equal(idealBatchMultiplier(bare.node), 2);
-});

package/src/lib/calc/worker/fill.ts

@@ -1,123 +0,0 @@
-import type { CalcNode, CalcRecipe } from '@terrafirmagreg-team/recipe/types/calc';
-import { pickAutoRecipe } from '@terrafirmagreg-team/recipe/lib/calc/resolve';
-import {
-  AUTO_NODE_BUDGET,
-  buildGoal,
-  type BuildContext,
-  type CalcGoal,
-} from '@terrafirmagreg-team/recipe/lib/calc/tree';
-import { createWorkerSummaries, fetchWanted } from './fetch';
-import { createFlush, postFlush } from './flush';
-import type { ResolveInput } from './protocol';
-import { state } from './state';
-
-export async function runFill(
-  input: ResolveInput & { roots: string[] },
-): Promise<Record<string, string>> {
-  const gen = state.fillGen;
-  const picks: Record<string, string> = {};
-  const openCollapsed = new Set<string>();
-  const localRecipes = new Map<string, CalcRecipe>(state.recipeMap);
-  const summaries = createWorkerSummaries(localRecipes);
-  const pending = createFlush();
-  const merged = { ...input.selections };
-  let latestGoals: CalcGoal[] | undefined;
-  for (let iter = 0; iter < 200 && input.roots.length; iter += 1) {
-    if (gen !== state.fillGen) return {};
-    Object.assign(merged, picks);
-    const ctxAuto = (
-      budget: number,
-    ): Omit<BuildContext, 'pool' | 'used' | 'usedMaterials'> => ({
-      recipeMap: localRecipes,
-      getRecipesForItem: summaries.get,
-      selections: merged,
-      tagSelections: input.tagSelections,
-      tagMembers: (id) => state.tagMap.get(id),
-      collapsed: openCollapsed,
-      autoRoots: input.roots,
-      autoBudget: { left: budget },
-      recipesResolved: (id) => state.outMap.has(id),
-      deadIds: state.deadIds,
-    });
-    const wanted = new Set<string>();
-    const wantedOut = new Set<string>();
-    const wantedTag = new Set<string>();
-    const built: CalcGoal[] = [];
-    if (input.target) {
-      const goalCtx = ctxAuto(AUTO_NODE_BUDGET);
-      const goal = buildGoal(input.target, goalCtx, 'g0', input.inventory);
-      built.push(goal);
-      const walk = (n: CalcNode, ancestors: Set<string>): void => {
-        const next =
-          n.recipe && n.need > 0
-            ? new Set(ancestors).add(`${n.kind}:${n.materialId}`)
-            : ancestors;
-        if (n.path) {
-          if (n.recipe) picks[n.path] = n.recipe.recipeId;
-          else if (n.auto && !n.catalyst && n.availableRecipes.length) {
-            const autoPick = pickAutoRecipe(n, merged, ancestors, goalCtx);
-            if (
-              autoPick.pick &&
-              !localRecipes.has(autoPick.pick) &&
-              !state.deadIds.has(autoPick.pick)
-            )
-              wanted.add(autoPick.pick);
-            for (const id of autoPick.wantRecipes) {
-              if (!localRecipes.has(id) && !state.deadIds.has(id)) wanted.add(id);
-            }
-            for (const id of autoPick.wantOut) {
-              if (!state.outMap.has(id)) wantedOut.add(id);
-            }
-          }
-        }
-        if (n.tagId && !state.tagMap.has(n.tagId)) {
-          wantedTag.add(n.tagId);
-        } else if (!state.outMap.has(n.materialId)) {
-          wantedOut.add(n.materialId);
-        }
-        for (const child of n.children) walk(child, next);
-      };
-      walk(goal.node, new Set());
-    }
-    for (const id of Object.values(merged)) {
-      if (id && !localRecipes.has(id) && !state.deadIds.has(id)) wanted.add(id);
-    }
-    latestGoals = built;
-    if (!wanted.size && !wantedOut.size && !wantedTag.size) break;
-    const progressed = await fetchWanted(
-      pending,
-      wanted,
-      wantedOut,
-      wantedTag,
-      localRecipes,
-    );
-    if (gen !== state.fillGen) return {};
-    if (!progressed) break;
-    summaries.clear();
-    if (iter % 5 === 4) postFlush(pending, latestGoals);
-  }
-  for (const [id, recipe] of localRecipes) {
-    if (!state.recipeMap.has(id)) {
-      state.recipeMap.set(id, recipe);
-      pending.recipes.set(id, recipe);
-      pending.dirty = true;
-    }
-  }
-  postFlush(pending, latestGoals);
-
-  const out: Record<string, string> = {};
-  const collect = (n: CalcNode): void => {
-    if (
-      n.path &&
-      n.recipe &&
-      input.roots.some(
-        (root) => n.path === root || n.path!.startsWith(`${root}/`),
-      )
-    ) {
-      out[n.path] = n.recipe.recipeId;
-    }
-    for (const child of n.children) collect(child);
-  };
-  for (const goal of latestGoals ?? []) collect(goal.node);
-  return out;
-}

package/src/lib/client-index/cache.ts

@@ -1,13 +0,0 @@
-
-export function memoPending<V>(
-  cache: Map<string, Promise<V>>,
-  key: string,
-  pending: Promise<V>,
-): Promise<V> {
-  const live = pending.catch((err: unknown) => {
-    cache.delete(key);
-    throw err;
-  });
-  cache.set(key, live);
-  return live;
-}

package/src/lib/forge/forge.test.ts

@@ -1,123 +0,0 @@
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-import {
-  FORGE_ACTIONS,
-  forgeRulesMatch,
-  parseForgeRuleTooltip,
-} from './actions';
-import { solveForgeSteps } from './solve';
-import type { ForgeRule, ForgeRuleAction } from '@terrafirmagreg-team/recipe/types/forge';
-
-const fresh = { work: 0, last: [] as ForgeRuleAction[] };
-
-test('parses dump tooltips and all rule positions', () => {
-  assert.deepEqual(parseForgeRuleTooltip('§aHit Second Last'), {
-    action: 'hit',
-    order: 'second_last',
-  });
-  assert.equal(parseForgeRuleTooltip('Unknown Last'), undefined);
-  for (const order of [
-    'last',
-    'second_last',
-    'third_last',
-    'not_last',
-    'any',
-  ] as const) {
-    const last: ForgeRuleAction[] = ['hit', 'bend', 'punch'];
-    assert.equal(
-      forgeRulesMatch([{ action: 'hit', order }], last),
-      order === 'last' || order === 'any',
-    );
-  }
-  assert.equal(
-    forgeRulesMatch([{ action: 'hit', order: 'not_last' }], ['hit']),
-    false,
-  );
-});
-
-test('finds shortest unconstrained paths and rejects invalid targets', () => {
-  assert.deepEqual(solveForgeSteps(fresh, 0, []), []);
-  assert.deepEqual(solveForgeSteps(fresh, 16, []), [7]);
-  for (const value of [-1, 150, NaN, 12.5]) {
-    assert.equal(solveForgeSteps(fresh, value, []), null);
-  }
-  const distance = new Int32Array(150).fill(-1);
-  distance[0] = 0;
-  const queue = [0];
-  for (const work of queue) {
-    for (const { delta } of FORGE_ACTIONS) {
-      const next = work + delta;
-      if (next < 0 || next >= 150 || distance[next] !== -1) continue;
-      distance[next] = distance[work] + 1;
-      queue.push(next);
-    }
-  }
-  for (let target = 0; target < 150; target++) {
-    assert.equal(
-      solveForgeSteps(fresh, target, [])?.length,
-      distance[target],
-    );
-  }
-});
-
-test('solutions respect work bounds and dumped finishing rules', () => {
-  const rules = ['Upset Last', 'Bend Not Last', 'Punch Not Last'].map(
-    (text) => parseForgeRuleTooltip(text)!,
-  );
-  for (const target of [40, 70, 100, 113, 149]) {
-    const steps = solveForgeSteps(fresh, target, rules);
-    assert.ok(steps);
-    let work = 0;
-    for (const step of steps) {
-      work += FORGE_ACTIONS[step].delta;
-      assert.ok(work >= 0 && work < 150);
-    }
-    assert.equal(work, target);
-    assert.ok(
-      forgeRulesMatch(
-        rules,
-        steps
-          .slice(-3)
-          .reverse()
-          .map((step) => FORGE_ACTIONS[step].action),
-      ),
-    );
-  }
-  assert.equal(
-    solveForgeSteps(fresh, 80, [
-      { action: 'hit', order: 'last' },
-      { action: 'bend', order: 'last' },
-    ]),
-    null,
-  );
-});
-
-test('solves from a mid-work state and respects existing history', () => {
-  const rules: ForgeRule[] = [{ action: 'punch', order: 'last' }];
-  const start = { work: 58, last: ['bend', 'upset'] as ForgeRuleAction[] };
-  const steps = solveForgeSteps(start, 70, rules);
-  assert.ok(steps);
-  let work = start.work;
-  for (const step of steps) work += FORGE_ACTIONS[step].delta;
-  assert.equal(work, 70);
-  const last = [...start.last, ...steps.map((i) => FORGE_ACTIONS[i].action)]
-    .slice(-3)
-    .reverse();
-  assert.ok(forgeRulesMatch(rules, last));
-
-  const solved = solveForgeSteps(
-    { work: 70, last: ['bend'] as ForgeRuleAction[] },
-    70,
-    rules,
-  );
-  assert.ok(solved && solved.length > 0);
-  assert.equal(FORGE_ACTIONS[solved.at(-1)!].action, 'punch');
-  assert.equal(
-    solveForgeSteps(
-      { work: 70, last: ['punch'] as ForgeRuleAction[] },
-      70,
-      rules,
-    )?.length,
-    0,
-  );
-});