@terrafirmagreg-team/recipe 0.1.0 → 1.2.1

package/src/hooks/calc/use-resolver.ts

@@ -1,73 +1,37 @@
 'use client';
 
 import { useAsyncEffect } from '@terrafirmagreg-team/ui/hooks/use-async-value';
-import {
-  AUTO_NODE_BUDGET,
-  buildGoal,
-  type BuildContext,
-} from '@terrafirmagreg-team/recipe/lib/calc/tree';
-import {
-  createFrameBudget,
-  createSummaries,
-  fetchSlices,
-  pickAutoRecipe,
-} from '@terrafirmagreg-team/recipe/lib/calc/resolve';
 import type { RecipeCompactIndex } from '@terrafirmagreg-team/recipe/types';
 import type {
-  CalcMaterial,
-  CalcNode,
-  CalculatorTarget,
-  TagResolution,
+  CalcCard,
+  CalcRecipe,
 } from '@terrafirmagreg-team/recipe/types/calc';
-import type { CalcMaps, CalcMapsSlice } from './use-maps';
 import type { useCalcWorker } from './use-worker';
 
 type WorkerSlice = ReturnType<typeof useCalcWorker>;
 
 export function useCalcResolver({
   catalog,
-  dataset,
   inputKey,
-  dataSettled,
-  activeTabId,
-  target,
-  inventory,
-  effectiveSelections,
-  tagSelections,
-  collapsed,
-  collapsedSet,
-  auto,
-  maps,
-  applyMaps,
+  cards,
+  recipeMap,
   worker,
 }: {
   catalog: RecipeCompactIndex | null;
-  dataset: string;
   inputKey: string;
-  dataSettled: boolean;
-  activeTabId: string | null;
-  target: CalculatorTarget | null;
-  inventory: CalcMaterial[];
-  effectiveSelections: Record<string, string>;
-  tagSelections: Record<string, string>;
-  collapsed: string[];
-  collapsedSet: Set<string>;
-  auto: string[];
-  maps: CalcMaps;
-  applyMaps: (src: CalcMapsSlice) => void;
+  cards: CalcCard[];
+  recipeMap: Map<string, CalcRecipe>;
   worker: WorkerSlice;
 }) {
-  const { outMap, tagMap, recipeMap, bodyMap, deadIds } = maps;
   const {
     ref: workerRef,
     state: workerState,
+    generation,
     call,
     isResolved,
     markResolved,
-    getCached,
-    applyResolved,
   } = worker;
-  useAsyncEffect(async (isCancelled) => {
+  useAsyncEffect(async () => {
     if (
       !catalog ||
       (!catalog.items.length && !catalog.fluids?.length) ||
@@ -75,160 +39,32 @@ export function useCalcResolver({
     ) {
       return;
     }
-    if (workerRef.current) {
+    if (!workerRef.current) return;
+    if (isResolved(inputKey)) return;
+    markResolved(inputKey);
 
-      if (isResolved(inputKey)) return;
-      markResolved(inputKey);
-
-      const hit = activeTabId ? getCached(activeTabId) : undefined;
-      if (hit?.inputKey === inputKey) {
-        if (isCancelled()) return;
-        applyResolved(hit);
-        return;
-      }
-      await call((api) =>
-          api.resolve({
-            target,
-            inventory,
-            selections: effectiveSelections,
-            tagSelections,
-            collapsed,
-            auto,
-          }),
-        )
-        .catch(() => {});
-      return;
+    const materials = new Set<string>();
+    const recipes = new Set<string>();
+    const tags = new Set<string>();
+    for (const card of cards) {
+      materials.add(card.materialId);
+      if (card.recipeId) recipes.add(card.recipeId);
     }
-
-    if (dataSettled) return;
-    const localOut = new Map(outMap);
-    const localTag = new Map(tagMap);
-    const localRecipes = new Map(recipeMap);
-    const localBodies = new Map(bodyMap);
-    const deadLocal = new Set(deadIds);
-    const { get: summaries, clear: clearSummaries } = createSummaries(
-      catalog,
-      localOut,
-      localRecipes,
-    );
-    const ctx = (): Omit<BuildContext, 'pool' | 'used' | 'usedMaterials'> => ({
-      recipeMap: localRecipes,
-      getRecipesForItem: summaries,
-      selections: effectiveSelections,
-      tagSelections,
-      tagMembers: (id: string) => localTag.get(id) as TagResolution | undefined,
-      collapsed: collapsedSet,
-      autoRoots: auto,
-      autoBudget: { left: AUTO_NODE_BUDGET },
-      recipesResolved: (id) => localOut.has(id),
-      deadIds: deadLocal,
-    });
-    let progressed = false;
-    const yieldToInput = createFrameBudget();
-    for (let iter = 0; iter < 200; iter += 1) {
-      await yieldToInput();
-      if (isCancelled()) return;
-      const wanted = new Set<string>();
-      const wantedOut = new Set<string>();
-      const wantedTag = new Set<string>();
-      if (target) {
-        const goalCtx = ctx();
-        const goal = buildGoal(target, goalCtx, 'g0', inventory);
-        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.tagId && !localTag.has(n.tagId)) wantedTag.add(n.tagId);
-          if (!localOut.has(n.materialId)) wantedOut.add(n.materialId);
-          if (n.recipe) {
-            for (const input of n.recipe.inputs) {
-              if (input.tagId && !localTag.has(input.tagId)) {
-                wantedTag.add(input.tagId);
-              }
-            }
-          } else if (n.auto) {
-            const autoPick = pickAutoRecipe(
-              n,
-              effectiveSelections,
-              ancestors,
-              goalCtx,
-            );
-            if (
-              autoPick.pick &&
-              !localRecipes.has(autoPick.pick) &&
-              !deadLocal.has(autoPick.pick)
-            ) {
-              wanted.add(autoPick.pick);
-            }
-            for (const id of autoPick.wantRecipes) {
-              if (!localRecipes.has(id) && !deadLocal.has(id)) wanted.add(id);
-            }
-            for (const id of autoPick.wantOut) {
-              if (!localOut.has(id)) wantedOut.add(id);
-            }
-          }
-          for (const child of n.children) walk(child, next);
-        };
-        walk(goal.node, new Set());
-      }
-      if (!wanted.size && !wantedOut.size && !wantedTag.size) break;
-      const slices = await fetchSlices(dataset, catalog, {
-        recipes: wanted,
-        outs: wantedOut,
-        tags: wantedTag,
-      });
-      if (isCancelled()) return;
-      let step = false;
-      for (const [id, entry] of slices.recipes) {
-        localRecipes.set(id, entry.calc);
-        localBodies.set(id, entry.body);
-        step = true;
-      }
-      for (const id of slices.dead) deadLocal.add(id);
-      for (const [id, list] of slices.outs) {
-        localOut.set(id, list);
-        clearSummaries();
-        step = true;
-      }
-      for (const [id, tag] of slices.tags) {
-        localTag.set(id, tag);
-        step = true;
-      }
-      progressed ||= step;
-      if (!step) break;
-      if (iter % 5 === 4) {
-        applyMaps({
-          out: localOut,
-          tag: localTag,
-          recipes: localRecipes,
-          bodies: localBodies,
-          dead: deadLocal,
-        });
+    for (const card of cards) {
+      if (!card.recipeId) continue;
+      const recipe = recipeMap.get(card.recipeId);
+      if (!recipe) continue;
+      for (const input of recipe.inputs) {
+        if (input.tagId) tags.add(input.tagId);
       }
     }
-    if (!progressed || isCancelled()) return;
-    applyMaps({
-      out: localOut,
-      tag: localTag,
-      recipes: localRecipes,
-      bodies: localBodies,
-      dead: deadLocal,
-    });
-  }, [
-    catalog,
-    dataSettled,
-    target,
-    inventory,
-    effectiveSelections,
-    tagSelections,
-    collapsed,
-    collapsedSet,
-    auto,
-    dataset,
-    workerState,
-    call,
-    activeTabId,
-    inputKey,
-  ]);
+    await call((api) =>
+      api.resolve({
+        materials: [...materials],
+        recipes: [...recipes],
+        tags: [...tags],
+      }),
+    ).catch(() => {});
+  }, [catalog, cards, recipeMap, workerState, generation, call, inputKey]);
 }
+

package/src/hooks/calc/use-session.ts

@@ -10,3 +10,4 @@ export const CalcSessionProvider = CalcSessionContext.Provider;
 export function useCalcSession(): RecipeSession | null {
   return useContext(CalcSessionContext);
 }
+

package/src/hooks/calc/use-share.ts

@@ -9,6 +9,7 @@ import {
 } from '@terrafirmagreg-team/recipe/lib/calc/storage';
 import { recipeCalcHref } from '@terrafirmagreg-team/recipe/lib/links';
 import { replaceUrlState } from '@terrafirmagreg-team/ui/lib/utils/history';
+import type { DatasetRef } from '@terrafirmagreg-team/sites/location';
 
 export function useCalcShare({
   storageKey,
@@ -17,7 +18,7 @@ export function useCalcShare({
   incoming,
 }: {
   storageKey: string;
-  dataset: string;
+  dataset: DatasetRef;
   lang: string;
   incoming: string;
 }): boolean {
@@ -26,8 +27,9 @@ export function useCalcShare({
   useEffect(() => {
     if (!isShareId) return;
     let cancelled = false;
+    const { id: datasetId, version } = dataset;
     void fetch(
-      `/api/share/recipe/${encodeURIComponent(dataset)}/${encodeURIComponent(incoming.slice(1))}`,
+      `/api/share/recipe/${encodeURIComponent(datasetId)}/${encodeURIComponent(incoming.slice(1))}${version ? `?version=${encodeURIComponent(version)}` : ''}`,
     )
       .then((res) => (res.ok ? res.json() : null))
       .then((body: { tree?: unknown } | null) => {
@@ -59,3 +61,4 @@ export function useCalcShare({
 
   return isShareId && sharedTree === null;
 }
+

package/src/hooks/calc/use-storage.ts

@@ -4,6 +4,7 @@ import { useCallback, useSyncExternalStore } from 'react';
 import {
   newCalcEntry,
   readCalcActive,
+  resolveCalcActive,
   readCalcHistory,
   readCalcStorage,
   readCalcTabs,
@@ -19,9 +20,8 @@ import type { CalculatorState } from '@terrafirmagreg-team/recipe/types/calc';
 
 const EMPTY_TABS: CalcTreeEntry[] = [];
 const EMPTY_CALC: CalculatorState = {
-  target: null,
-  inventory: [],
-  selections: {},
+  cards: [],
+  wires: [],
   tagSelections: {},
 };
 
@@ -42,7 +42,7 @@ export function useCalcStorage(storageKey: string) {
   );
   const activeTabId = useSyncExternalStore(
     subscribeCalcStorage,
-    () => readCalcActive(storageKey),
+    () => resolveCalcActive(readCalcTabs(storageKey), readCalcActive(storageKey)),
     () => null,
   );
   const history = useSyncExternalStore(
@@ -123,3 +123,4 @@ export function useCalcStorage(storageKey: string) {
     removeHistory,
   };
 }
+

package/src/hooks/calc/use-tier.ts

@@ -10,3 +10,4 @@ export const CalcTierProvider = CalcTierContext.Provider;
 export function useCalcTier(): CalcTier {
   return useContext(CalcTierContext);
 }
+

package/src/hooks/calc/use-view-mode.ts

@@ -21,3 +21,4 @@ export function useCalcViewMode() {
   );
   return [mode, setMode] as const;
 }
+

package/src/hooks/calc/use-worker.ts

@@ -1,4 +1,5 @@
 'use client';
+import type { DatasetRef } from '@terrafirmagreg-team/sites/location';
 
 import {
   startTransition,
@@ -12,64 +13,44 @@ import type {
   CalcWorkerApi,
   CalcWorkerFlush,
 } from '@terrafirmagreg-team/recipe/lib/calc/worker';
-import type { CalcGoal } from '@terrafirmagreg-team/recipe/lib/calc/tree';
+import { api as localCalcApi } from '@terrafirmagreg-team/recipe/lib/calc/worker/api';
 import type { RecipeCompactIndex } from '@terrafirmagreg-team/recipe/types';
-import type { CalcMaterial } from '@terrafirmagreg-team/recipe/types/calc';
 import type { CalcMapsSlice } from './use-maps';
 
 type CalcWorkerHandle = {
-  worker: Worker;
+  worker: Worker | null;
   api: Remote<CalcWorkerApi>;
   inFlight: number;
   rejecters: Set<(error: Error) => void>;
 };
 
-export type ResolvedCacheEntry = {
-  inputKey: string;
-  goals: CalcGoal[];
-  summary: { raw: CalcMaterial[]; catalysts: CalcMaterial[] } | null;
-};
-
 export function useCalcWorker({
   dataset,
   catalog,
   activeTabId,
-  inputKey,
   applyMaps,
   resetMaps,
 }: {
-  dataset: string;
+  dataset: DatasetRef;
   catalog: RecipeCompactIndex | null;
   activeTabId: string | null;
-  inputKey: string;
   applyMaps: (src: CalcMapsSlice, extra?: () => void) => void;
   resetMaps: () => void;
 }) {
   const workerRef = useRef<CalcWorkerHandle | null>(null);
-  const [workerState, setWorkerState] = useState<
-    'pending' | 'ready' | 'failed'
-  >('pending');
-
-  const [workerGoals, setWorkerGoals] = useState<CalcGoal[] | null>(null);
-  const [workerSummary, setWorkerSummary] = useState<{
-    raw: CalcMaterial[];
-    catalysts: CalcMaterial[];
-  } | null>(null);
+  const [workerState, setWorkerState] = useState<'pending' | 'ready'>(
+    'pending',
+  );
+  const [generation, setGeneration] = useState(0);
   const [workerSettled, setWorkerSettled] = useState(false);
-
   const resolvedKeyRef = useRef<string | null>(null);
 
-  const resolvedCacheRef = useRef(new Map<string, ResolvedCacheEntry>());
-
-  const [prevActiveTab, setPrevActiveTab] = useState(activeTabId);
-  if (prevActiveTab !== activeTabId) {
-    setPrevActiveTab(activeTabId);
-    setWorkerGoals(null);
-    setWorkerSummary(null);
+  const minFlushEpochRef = useRef(0);
+  const [prevTab, setPrevTab] = useState(activeTabId);
+  if (prevTab !== activeTabId) {
+    setPrevTab(activeTabId);
     setWorkerSettled(false);
   }
-
-  const minFlushEpochRef = useRef(0);
   useEffect(() => {
     resolvedKeyRef.current = null;
     minFlushEpochRef.current += 1;
@@ -77,35 +58,16 @@ export function useCalcWorker({
     if (handle) void handle.api.invalidate().catch(() => {});
   }, [activeTabId]);
 
-  useEffect(() => {
-    if (!workerSettled || !activeTabId) return;
-    if (resolvedKeyRef.current !== inputKey) return;
-    resolvedCacheRef.current.set(activeTabId, {
-      inputKey,
-      goals: workerGoals ?? [],
-      summary: workerSummary,
-    });
-  }, [workerSettled, workerGoals, workerSummary, activeTabId, inputKey]);
-
   const applyWorkerFlush = useCallback(
     (msg: CalcWorkerFlush) => {
-
-      const stale = msg.epoch < minFlushEpochRef.current;
-      applyMaps(
-        {
-          out: new Map(msg.out),
-          tag: new Map(msg.tag),
-          recipes: new Map(msg.recipes),
-          bodies: new Map(msg.bodies),
-          dead: new Set(msg.dead),
-        },
-        () => {
-          if (!stale) {
-            if (msg.goals) setWorkerGoals(msg.goals);
-            if (msg.summary) setWorkerSummary(msg.summary);
-          }
-        },
-      );
+      if (msg.epoch < minFlushEpochRef.current) return;
+      applyMaps({
+        out: new Map(msg.out),
+        tag: new Map(msg.tag),
+        recipes: new Map(msg.recipes),
+        bodies: new Map(msg.bodies),
+        dead: new Set(msg.dead),
+      });
     },
     [applyMaps],
   );
@@ -128,20 +90,7 @@ export function useCalcWorker({
             recipes: [...prev.recipes, ...msg.recipes],
             bodies: [...prev.bodies, ...msg.bodies],
             dead: [...prev.dead, ...msg.dead],
-
             epoch: Math.max(prev.epoch, msg.epoch),
-            goals:
-              msg.epoch > prev.epoch
-                ? msg.goals
-                : msg.epoch === prev.epoch
-                  ? (msg.goals ?? prev.goals)
-                  : prev.goals,
-            summary:
-              msg.epoch > prev.epoch
-                ? msg.summary
-                : msg.epoch === prev.epoch
-                  ? (msg.summary ?? prev.summary)
-                  : prev.summary,
           }
         : msg;
       if (flushTimer.current) return;
@@ -152,54 +101,53 @@ export function useCalcWorker({
 
   useEffect(() => {
     if (!catalog) return;
-    if (typeof Worker === 'undefined') {
-      queueMicrotask(() => setWorkerState('failed'));
-      return;
-    }
-    let worker: Worker;
-    try {
-      worker = new Worker(
-        new URL('../../lib/calc/worker/index.ts', import.meta.url),
-        { type: 'module' },
-      );
-    } catch {
-      queueMicrotask(() => setWorkerState('failed'));
-      return;
-    }
-    const fail = () => {
-      workerRef.current = null;
-      worker.terminate();
-      setWorkerState('failed');
-      setWorkerGoals(null);
-      setWorkerSummary(null);
-      setWorkerSettled(false);
-    };
     const handle: CalcWorkerHandle = {
-      worker,
-      api: wrap<CalcWorkerApi>(worker),
+      worker: null,
+      api: localCalcApi as Remote<CalcWorkerApi>,
       inFlight: 0,
       rejecters: new Set(),
     };
-    worker.onerror = () => {
-      fail();
+    const swapToLocal = () => {
+      handle.worker = null;
+      handle.api = localCalcApi as Remote<CalcWorkerApi>;
       const error = new Error('calc worker failed');
       for (const reject of handle.rejecters) reject(error);
       handle.rejecters.clear();
+      bufferedFlush.current = null;
+      if (flushTimer.current) {
+        clearTimeout(flushTimer.current);
+        flushTimer.current = null;
+      }
+      resolvedKeyRef.current = null;
+      minFlushEpochRef.current = 0;
+      setGeneration((g) => g + 1);
+      void handle.api.init(dataset, catalog, scheduleWorkerFlush).catch(() => {});
     };
+    if (typeof Worker !== 'undefined') {
+      try {
+        const worker = new Worker(
+          new URL('../../lib/calc/worker/index.ts', import.meta.url),
+          { type: 'module' },
+        );
+        worker.onerror = () => swapToLocal();
+        handle.worker = worker;
+        handle.api = wrap<CalcWorkerApi>(worker);
+      } catch {
+      }
+    }
     handle.api
-      .init(dataset, catalog, proxy(scheduleWorkerFlush))
+      .init(
+        dataset,
+        catalog,
+        handle.worker ? proxy(scheduleWorkerFlush) : scheduleWorkerFlush,
+      )
       .then(() => setWorkerState('ready'))
-      .catch(() => fail());
+      .catch(() => {});
     workerRef.current = handle;
     resolvedKeyRef.current = null;
-    resolvedCacheRef.current.clear();
     minFlushEpochRef.current = 0;
     resetMaps();
-    startTransition(() => {
-      setWorkerGoals(null);
-      setWorkerSummary(null);
-      setWorkerSettled(false);
-    });
+    startTransition(() => setWorkerSettled(false));
     return () => {
       if (flushTimer.current) {
         clearTimeout(flushTimer.current);
@@ -207,7 +155,7 @@ export function useCalcWorker({
       }
       bufferedFlush.current = null;
       workerRef.current = null;
-      worker.terminate();
+      handle.worker?.terminate();
     };
   }, [dataset, catalog, scheduleWorkerFlush, resetMaps]);
 
@@ -241,29 +189,16 @@ export function useCalcWorker({
     [drainFlush],
   );
 
-  const applyResolved = useCallback((entry: ResolvedCacheEntry) => {
-    startTransition(() => {
-      setWorkerGoals(entry.goals);
-      setWorkerSummary(entry.summary);
-      setWorkerSettled(true);
-    });
-  }, []);
-
   return {
     ref: workerRef,
     state: workerState,
-    goals: workerGoals,
-    summary: workerSummary,
+    generation,
     settled: workerSettled,
     call,
     isResolved: useCallback((key: string) => resolvedKeyRef.current === key, []),
     markResolved: useCallback((key: string) => {
       resolvedKeyRef.current = key;
     }, []),
-    getCached: useCallback(
-      (tabId: string) => resolvedCacheRef.current.get(tabId),
-      [],
-    ),
-    applyResolved,
   };
 }
+

package/src/hooks/forge/use-anvil-gui.ts

@@ -1,14 +1,16 @@
 'use client';
+import type { DatasetRef } from '@terrafirmagreg-team/sites/location';
 import { useSyncExternalStore } from 'react';
 import {
   dumpLocation,
   dumpPublicUrl,
   subscribeDumpLocations,
-} from '@terrafirmagreg-team/game/lib/dump/paths';
+} from '@terrafirmagreg-team/dump/lib/dump/paths';
 
 export const ANVIL_GUI_REL = 'assets/tfc/textures/gui/anvil.webp';
 
-export function useAnvilGui(dataset: string): string | undefined {
+export function useAnvilGui(dataset: DatasetRef): string | undefined {
   useSyncExternalStore(subscribeDumpLocations, () => dumpLocation(dataset));
   return dumpPublicUrl(dataset, ANVIL_GUI_REL);
 }
+

package/src/hooks/forge/use-forge-state.ts

@@ -132,3 +132,4 @@ export function useForgeState(recipe: ForgeRecipe) {
 }
 
 export type ForgeState = ReturnType<typeof useForgeState>;
+

package/src/hooks/forge/use-ruler.ts

@@ -97,3 +97,4 @@ export function useRuler({
     onHandleKey,
   };
 }
+