@ibgib/core-gib 0.1.9 → 0.1.11

package/src/witness/space/space-helper.respec.mts

@@ -0,0 +1,42 @@
+import { respecfully, ifWe, iReckon } from '@ibgib/helper-gib/dist/respec-gib/respec-gib.mjs';
+import { InnerSpace_V1 } from './inner-space/inner-space-v1.mjs';
+import { DEFAULT_INNER_SPACE_DATA_V1 } from './inner-space/inner-space-types.mjs';
+import { lockSpace, unlockSpace } from './space-helper.mjs';
+
+const maam = `[${import.meta.url}]`, sir = maam;
+
+await respecfully(sir, 'space-helper', async () => {
+
+    await respecfully(sir, 'lockSpace', async () => {
+
+        await ifWe(sir, 'should fail if two locks are acquired simultaneously on the same scope (race condition check)', async () => {
+            const space = new InnerSpace_V1(DEFAULT_INNER_SPACE_DATA_V1, undefined);
+
+            // initialize the space first (often required for internal structures)
+            await space.initialized;
+
+            const scope = 'test-lock-scope';
+            const secondsValid = 5;
+
+            // Try to acquire lock simultaneously from two "instances"
+            const p1 = lockSpace({ space, scope, secondsValid, instanceId: 'A' });
+            const p2 = lockSpace({ space, scope, secondsValid, instanceId: 'B' });
+
+            const [res1, res2] = await Promise.all([p1, p2]);
+
+            // Expectation: Only one should succeed
+            const success1 = res1.data?.success;
+            const success2 = res2.data?.success;
+
+            // If both verify, we have a problem (race condition)
+            // We reckon that NOT both are true.
+            iReckon(sir, success1 && success2).asTo('both locks acquired (mutual exclusion failed)').isGonnaBeFalse();
+
+            // Clean up
+            await unlockSpace({ space, scope, instanceId: 'A' });
+            await unlockSpace({ space, scope, instanceId: 'B' });
+        });
+
+    });
+
+});

package/tmp.md

@@ -0,0 +1,11 @@
+OK, ty. The space-wide sync approach is not tenable. That is like trying to sync Alice's entire logical drive with Bob's entire logical drive instead of a particular folder on the drive. Your thinking that a single Domain IbGib does not contain many timelines is faulty. A dependency graph of a "single" domain may contain multiple, or even many/a great many, timelines. Think of this like in set theory and we are creating an isomorphic projection of nodes. I say isomorphic and not homomorphic, because we may have to do merges for timelines, so it really is a "one-way" projection. Though obviously, with "sync" being bi-directional, we are ultimately converging on both endpoints having "equivalent" timelines (there may be orphans on one and/or the other after merges, with either endpoint effectively doing a "rebase"). So our sync process has to start with getting a "live" dependency graph of a single domain ibgib. We can actually do multiple domain ibgibs, and then unify the entire dependency graph in the sync transmission ibgib, but I think it's best to just build for the single ibgib scenario. You can look at@beautifulMention, but I would really recommend looking at the entire @beautifulMentionfile. This is a non-trivial recursive function, but you should be able to fully grok it by looking at both the jsdocs/comments in that file and the code itself. Always look at the code itself of course!
+
+That dependency graph comes in the form a @beautifulMention as defined by this:
+
+```
+/**
+ * Map of addr -> ibGib
+ */
+export type FlatIbGibGraph = { [addr: string]: IbGib_V1 };
+```
+