akanjs 3.0.0-alpha.89 → 3.0.0-alpha.90

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akanjs",
-  "version": "3.0.0-alpha.89",
+  "version": "3.0.0-alpha.90",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {

package/store/stateBuilder.ts

@@ -10,6 +10,7 @@ import {
   type PrimitiveScalar,
 } from "akanjs/base";
 import { ConstantRegistry } from "akanjs/constant";
+import { databaseStateNames } from "./databaseStateNames";
 
 export type StateInitializer = () => unknown;
 export type StateInitializerMap = Record<string, StateInitializer>;
@@ -155,6 +156,25 @@ export interface DerivedStateBuilder<WritableState> {
   };
 }
 
+const draftMetaByRefName = new Map<string, DraftMeta>();
+
+/**
+ * The one `DraftMeta` for a model, memoized.
+ *
+ * Every field of it is derived from the refName, so two stores for the same model describe the same thing. They
+ * have to describe it with the *same object*, though: an app store that extends a lib store for one model carries
+ * the lib's copy and registers its own, and both reach `mergeDerivedMeta` — where an entry is a conflict only when
+ * two declarations disagree, which is decided by identity.
+ */
+export const draftMetaOf = (refName: string): DraftMeta => {
+  const cached = draftMetaByRefName.get(refName);
+  if (cached) return cached;
+  const names = databaseStateNames(refName);
+  const meta: DraftMeta = { refName, formKey: names.modelForm, draftKey: names.modelDraft };
+  draftMetaByRefName.set(refName, meta);
+  return meta;
+};
+
 export const createEmptyDerivedMeta = (): StateDerivedMeta => ({
   drafts: {},
   persistSession: {},
@@ -171,17 +191,26 @@ export const mergeDerivedMeta = (...metas: (StateDerivedMeta | undefined)[]): St
     mergeMetaRecord(merged.persistSession, meta.persistSession);
     mergeMetaRecord(merged.search, meta.search);
     mergeMetaRecord(merged.computed, meta.computed);
-    for (const key of meta.derivedKeys) {
-      if (merged.derivedKeys.has(key)) throw new Error(`Duplicate derived state key: ${key}`);
-      merged.derivedKeys.add(key);
-    }
   }
+
+  for (const key of [...Object.keys(merged.search), ...Object.keys(merged.computed)]) merged.derivedKeys.add(key);
   return merged;
 };
 
+/**
+ * Copies `source` over `target`, rejecting only a genuine conflict.
+ *
+ * The same key arriving twice is normal: a store lists another as a lib store, so it already carries that store's
+ * metadata when both are registered and `StoreRegistry.merge` sees each of them. What arrives then is the very
+ * object the first declaration produced, because merging copies the reference. Two *different* objects under one
+ * key are two declarations claiming the same state, which is the mistake this is here to catch.
+ */
 const mergeMetaRecord = <T>(target: Record<string, T>, source: Record<string, T>) => {
   for (const [key, value] of Object.entries(source)) {
-    if (key in target) throw new Error(`Duplicate state metadata key: ${key}`);
+    if (key in target) {
+      if (Object.is(target[key], value)) continue;
+      throw new Error(`Duplicate state metadata key: ${key}`);
+    }
     target[key] = value;
   }
 };

package/store/store.ts

@@ -26,7 +26,6 @@ import type {
 } from "akanjs/signal";
 import { type DefaultAction, makeActions, makeFormSetter } from "./action";
 import type { ActionOwner } from "./actionTag";
-import { databaseStateNames } from "./databaseStateNames";
 import { createDatabaseState, createSliceState, type DefaultState } from "./state";
 import {
   createDerivedStateBuilder,
@@ -35,6 +34,7 @@ import {
   createWritableStateBuilder,
   type DerivedStateBuilder,
   type DerivedStateOf,
+  draftMetaOf,
   mergeDerivedMeta,
   resolveDerivedState,
   resolveWritableState,
@@ -218,12 +218,8 @@ export function store<Sig extends ClientSignal<any, any, any> | string, State>(
     };
     Object.assign(storeCls[STATE_META], signalState);
     Object.assign(storeCls[STATE_INIT_META], createStateInitializerMap(signalState));
-    const draftNames = databaseStateNames(refName);
-    storeCls[STATE_DERIVED_META].drafts[draftNames.modelForm] = {
-      refName,
-      formKey: draftNames.modelForm,
-      draftKey: draftNames.modelDraft,
-    };
+    const draftMeta = draftMetaOf(refName);
+    storeCls[STATE_DERIVED_META].drafts[draftMeta.formKey] = draftMeta;
     const actions = {
       ...makeFormSetter(refName, signal.fetch),
       ...makeActions(refName, signal.serializedSignal.slice ?? {}, signal.fetch),

package/types/store/stateBuilder.d.ts

@@ -132,6 +132,15 @@ export interface DerivedStateBuilder<WritableState> {
         options: ComputedOptions<Result>;
     };
 }
+/**
+ * The one `DraftMeta` for a model, memoized.
+ *
+ * Every field of it is derived from the refName, so two stores for the same model describe the same thing. They
+ * have to describe it with the *same object*, though: an app store that extends a lib store for one model carries
+ * the lib's copy and registers its own, and both reach `mergeDerivedMeta` — where an entry is a conflict only when
+ * two declarations disagree, which is decided by identity.
+ */
+export declare const draftMetaOf: (refName: string) => DraftMeta;
 export declare const createEmptyDerivedMeta: () => StateDerivedMeta;
 export declare const mergeDerivedMeta: (...metas: (StateDerivedMeta | undefined)[]) => StateDerivedMeta;
 export declare const createWritableStateBuilder: () => WritableStateBuilder;