refactor(daemon): Provide

packages/daemon/src/daemon.js

@@ -181,12 +181,11 @@ const makeDaemonCore = async (
   );
 
   /**
-   * The two functions "formulate" and "provideValueForFormulaIdentifier"
-   * share a responsibility for maintaining the memoization tables
-   * "controllerForFormulaIdentifier" and "formulaIdentifierForRef".
-   * "formulate" is used for incarnating and persisting
-   * new formulas, whereas "provideValueForFormulaIdentifier" is used for
-   * reincarnating stored formulas.
+   * The two functions "formulate" and "provide" share a responsibility for
+   * maintaining the memoization tables "controllerForFormulaIdentifier" and
+   * "formulaIdentifierForRef".
+   * "formulate" is used for incarnating and persisting new formulas, whereas
+   * "provide" is used for reincarnating stored formulas.
    */
 
   /**
@@ -315,7 +314,7 @@ const makeDaemonCore = async (
       formulaIdentifiers.map(formulaIdentifier =>
         // Behold, recursion:
         // eslint-disable-next-line no-use-before-define
-        provideValueForFormulaIdentifier(formulaIdentifier),
+        provide(formulaIdentifier),
       ),
     );
 
@@ -355,7 +354,7 @@ const makeDaemonCore = async (
 
     // Behold, recursion:
     // eslint-disable-next-line no-use-before-define
-    const hub = provideValueForFormulaIdentifier(hubFormulaIdentifier);
+    const hub = provide(hubFormulaIdentifier);
     // @ts-expect-error calling lookup on an unknown object
     const external = E(hub).lookup(...path);
     return { external, internal: undefined };
@@ -390,7 +389,7 @@ const makeDaemonCore = async (
     const guestP = /** @type {Promise<import('./types.js').EndoGuest>} */ (
       // Behold, recursion:
       // eslint-disable-next-line no-use-before-define
-      provideValueForFormulaIdentifier(guestFormulaIdentifier)
+      provide(guestFormulaIdentifier)
     );
     const external = E(workerDaemonFacet).makeUnconfined(
       specifier,
@@ -433,12 +432,12 @@ const makeDaemonCore = async (
       /** @type {Promise<import('./types.js').EndoReadable>} */ (
         // Behold, recursion:
         // eslint-disable-next-line no-use-before-define
-        provideValueForFormulaIdentifier(bundleFormulaIdentifier)
+        provide(bundleFormulaIdentifier)
       );
     const guestP = /** @type {Promise<import('./types.js').EndoGuest>} */ (
       // Behold, recursion:
       // eslint-disable-next-line no-use-before-define
-      provideValueForFormulaIdentifier(guestFormulaIdentifier)
+      provide(guestFormulaIdentifier)
     );
     const external = E(workerDaemonFacet).makeBundle(
       readableBundleP,
@@ -535,7 +534,7 @@ const makeDaemonCore = async (
             );
           }
           // eslint-disable-next-line no-use-before-define
-          return provideValueForFormulaIdentifier(requestedFormulaIdentifier);
+          return provide(requestedFormulaIdentifier);
         },
       });
       /** @type {import('./types.js').FarEndoBootstrap} */
@@ -549,14 +548,14 @@ const makeDaemonCore = async (
           // Behold, recursion:
           return /** @type {Promise<import('./types.js').EndoHost>} */ (
             // eslint-disable-next-line no-use-before-define
-            provideValueForFormulaIdentifier(formula.host)
+            provide(formula.host)
           );
         },
         leastAuthority: () => {
           // Behold, recursion:
           return /** @type {Promise<import('./types.js').EndoGuest>} */ (
             // eslint-disable-next-line no-use-before-define
-            provideValueForFormulaIdentifier(leastAuthorityFormulaIdentifier)
+            provide(leastAuthorityFormulaIdentifier)
           );
         },
         gateway: async () => {
@@ -567,15 +566,15 @@ const makeDaemonCore = async (
             /** @type {import('./types.js').EndoDirectory} */ (
               // Behold, recursion:
               // eslint-disable-next-line no-use-before-define
-              await provideValueForFormulaIdentifier(formula.networks)
+              await provide(formula.networks)
             );
           const networkFormulaIdentifiers =
             await networksDirectory.listIdentifiers();
           await Promise.allSettled(
             networkFormulaIdentifiers.map(
               // Behold, recursion:
               // eslint-disable-next-line no-use-before-define
-              provideValueForFormulaIdentifier,
+              provide,
             ),
           );
         },
@@ -584,7 +583,7 @@ const makeDaemonCore = async (
             /** @type {import('./types.js').PetStore} */
             // Behold, recursion:
             // eslint-disable-next-line no-use-before-define
-            (await provideValueForFormulaIdentifier(formula.peers));
+            (await provide(formula.peers));
           const { node, addresses } = peerInfo;
           // eslint-disable-next-line no-use-before-define
           const nodeName = petStoreNameForNodeIdentifier(node);
@@ -607,7 +606,7 @@ const makeDaemonCore = async (
       // Behold, forward-reference:
       const loopbackNetwork = makeLoopbackNetwork({
         // eslint-disable-next-line no-use-before-define
-        provideValueForFormulaIdentifier,
+        provide,
       });
       return {
         external: loopbackNetwork,
@@ -819,7 +818,7 @@ const makeDaemonCore = async (
     }
     const peerStore = /** @type {import('./types.js').PetStore} */ (
       // eslint-disable-next-line no-use-before-define
-      await provideValueForFormulaIdentifier(peersFormulaIdentifier)
+      await provide(peersFormulaIdentifier)
     );
     const nodeName = petStoreNameForNodeIdentifier(nodeIdentifier);
     const peerFormulaIdentifier = peerStore.identifyLocal(nodeName);
@@ -839,8 +838,8 @@ const makeDaemonCore = async (
     return controller.context.cancel(reason);
   };
 
-  /** @type {import('./types.js').DaemonCore['provideValueForFormulaIdentifier']} */
-  const provideValueForFormulaIdentifier = formulaIdentifier => {
+  /** @type {import('./types.js').DaemonCore['provide']} */
+  const provide = formulaIdentifier => {
     const controller = /** @type {import('./types.js').Controller<>} */ (
       provideControllerForFormulaIdentifier(formulaIdentifier)
     );
@@ -1471,13 +1470,11 @@ const makeDaemonCore = async (
   const getAllNetworks = async networksDirectoryFormulaIdentifier => {
     const networksDirectory = /** @type {import('./types').EndoDirectory} */ (
       // eslint-disable-next-line no-use-before-define
-      await provideValueForFormulaIdentifier(networksDirectoryFormulaIdentifier)
+      await provide(networksDirectoryFormulaIdentifier)
     );
     const networkFormulaIdentifiers = await networksDirectory.listIdentifiers();
     const networks = /** @type {import('./types').EndoNetwork[]} */ (
-      await Promise.all(
-        networkFormulaIdentifiers.map(provideValueForFormulaIdentifier),
-      )
+      await Promise.all(networkFormulaIdentifiers.map(provide))
     );
     return networks;
   };
@@ -1554,7 +1551,7 @@ const makeDaemonCore = async (
     remoteValueFormulaIdentifier,
   ) => {
     const peer = /** @type {import('./types.js').EndoPeer} */ (
-      await provideValueForFormulaIdentifier(peerFormulaIdentifier)
+      await provide(peerFormulaIdentifier)
     );
     const remoteValueP = peer.provide(remoteValueFormulaIdentifier);
     const external = remoteValueP;
@@ -1568,25 +1565,25 @@ const makeDaemonCore = async (
   });
 
   const { makeIdentifiedDirectory, makeDirectoryNode } = makeDirectoryMaker({
-    provideValueForFormulaIdentifier,
+    provide,
     getFormulaIdentifierForRef,
     incarnateDirectory,
   });
 
   const makeMailbox = makeMailboxMaker({
-    provideValueForFormulaIdentifier,
+    provide,
     provideControllerForFormulaIdentifierAndResolveHandle,
   });
 
   const makeIdentifiedGuestController = makeGuestMaker({
-    provideValueForFormulaIdentifier,
+    provide,
     provideControllerForFormulaIdentifierAndResolveHandle,
     makeMailbox,
     makeDirectoryNode,
   });
 
   const makeIdentifiedHost = makeHostMaker({
-    provideValueForFormulaIdentifier,
+    provide,
     provideControllerForFormulaIdentifier,
     cancelValue,
     incarnateWorker,
@@ -1613,7 +1610,7 @@ const makeDaemonCore = async (
    */
   const makePetStoreInspector = async petStoreFormulaIdentifier => {
     const petStore = /** @type {import('./types').PetStore} */ (
-      await provideValueForFormulaIdentifier(petStoreFormulaIdentifier)
+      await provide(petStoreFormulaIdentifier)
     );
 
     /**
@@ -1644,22 +1641,19 @@ const makeDaemonCore = async (
           harden({
             endowments: Object.fromEntries(
               formula.names.map((name, index) => {
-                return [
-                  name,
-                  provideValueForFormulaIdentifier(formula.values[index]),
-                ];
+                return [name, provide(formula.values[index])];
               }),
             ),
             source: formula.source,
-            worker: provideValueForFormulaIdentifier(formula.worker),
+            worker: provide(formula.worker),
           }),
         );
       } else if (formula.type === 'lookup') {
         return makeInspector(
           formula.type,
           formulaNumber,
           harden({
-            hub: provideValueForFormulaIdentifier(formula.hub),
+            hub: provide(formula.hub),
             path: formula.path,
           }),
         );
@@ -1668,27 +1662,27 @@ const makeDaemonCore = async (
           formula.type,
           formulaNumber,
           harden({
-            host: provideValueForFormulaIdentifier(formula.host),
+            host: provide(formula.host),
           }),
         );
       } else if (formula.type === 'make-bundle') {
         return makeInspector(
           formula.type,
           formulaNumber,
           harden({
-            bundle: provideValueForFormulaIdentifier(formula.bundle),
-            powers: provideValueForFormulaIdentifier(formula.powers),
-            worker: provideValueForFormulaIdentifier(formula.worker),
+            bundle: provide(formula.bundle),
+            powers: provide(formula.powers),
+            worker: provide(formula.worker),
           }),
         );
       } else if (formula.type === 'make-unconfined') {
         return makeInspector(
           formula.type,
           formulaNumber,
           harden({
-            powers: provideValueForFormulaIdentifier(formula.powers),
+            powers: provide(formula.powers),
             specifier: formula.type,
-            worker: provideValueForFormulaIdentifier(formula.worker),
+            worker: provide(formula.worker),
           }),
         );
       } else if (formula.type === 'peer') {
@@ -1719,7 +1713,7 @@ const makeDaemonCore = async (
     nodeIdentifier: ownNodeIdentifier,
     provideControllerForFormulaIdentifier,
     provideControllerForFormulaIdentifierAndResolveHandle,
-    provideValueForFormulaIdentifier,
+    provide,
     formulate,
     getFormulaIdentifierForRef,
     getAllNetworkAddresses,
@@ -1771,7 +1765,7 @@ const provideEndoBootstrap = async (
       node: daemonCore.nodeIdentifier,
     });
     return /** @type {Promise<import('./types.js').FarEndoBootstrap>} */ (
-      daemonCore.provideValueForFormulaIdentifier(endoFormulaIdentifier)
+      daemonCore.provide(endoFormulaIdentifier)
     );
   } else {
     const { value: endoBootstrap } = await daemonCore.incarnateEndoBootstrap(

packages/daemon/src/directory.js

@@ -7,12 +7,12 @@ const { quote: q } = assert;
 
 /**
  * @param {object} args
- * @param {import('./types.js').DaemonCore['provideValueForFormulaIdentifier']} args.provideValueForFormulaIdentifier
+ * @param {import('./types.js').DaemonCore['provide']} args.provide
  * @param {import('./types.js').DaemonCore['getFormulaIdentifierForRef']} args.getFormulaIdentifierForRef
  * @param {import('./types.js').DaemonCore['incarnateDirectory']} args.incarnateDirectory
  */
 export const makeDirectoryMaker = ({
-  provideValueForFormulaIdentifier,
+  provide,
   getFormulaIdentifierForRef,
   incarnateDirectory,
 }) => {
@@ -27,7 +27,7 @@ export const makeDirectoryMaker = ({
       }
       // Behold, recursion:
       // eslint-disable-next-line no-use-before-define
-      const value = provideValueForFormulaIdentifier(formulaIdentifier);
+      const value = provide(formulaIdentifier);
       return tailNames.reduce(
         // @ts-expect-error We assume its a NameHub
         (directory, petName) => E(directory).lookup(petName),
@@ -219,7 +219,7 @@ export const makeDirectoryMaker = ({
     // TODO thread context
 
     const petStore = /** @type {import('./types.js').PetStore} */ (
-      await provideValueForFormulaIdentifier(petStoreFormulaIdentifier)
+      await provide(petStoreFormulaIdentifier)
     );
     const directory = makeDirectoryNode(petStore);
 

packages/daemon/src/guest.js

@@ -6,13 +6,13 @@ import { makePetSitter } from './pet-sitter.js';
 
 /**
  * @param {object} args
- * @param {import('./types.js').DaemonCore['provideValueForFormulaIdentifier']} args.provideValueForFormulaIdentifier
+ * @param {import('./types.js').DaemonCore['provide']} args.provide
  * @param {import('./types.js').DaemonCore['provideControllerForFormulaIdentifierAndResolveHandle']} args.provideControllerForFormulaIdentifierAndResolveHandle
  * @param {import('./types.js').MakeMailbox} args.makeMailbox
  * @param {import('./types.js').MakeDirectoryNode} args.makeDirectoryNode
  */
 export const makeGuestMaker = ({
-  provideValueForFormulaIdentifier,
+  provide,
   provideControllerForFormulaIdentifierAndResolveHandle,
   makeMailbox,
   makeDirectoryNode,
@@ -36,7 +36,7 @@ export const makeGuestMaker = ({
     context.thisDiesIfThatDies(mainWorkerFormulaIdentifier);
 
     const basePetStore = /** @type {import('./types.js').PetStore} */ (
-      await provideValueForFormulaIdentifier(petStoreFormulaIdentifier)
+      await provide(petStoreFormulaIdentifier)
     );
     const specialStore = makePetSitter(basePetStore, {
       SELF: guestFormulaIdentifier,

packages/daemon/src/host.js

@@ -15,7 +15,7 @@ const assertPowersName = name => {
 
 /**
  * @param {object} args
- * @param {import('./types.js').DaemonCore['provideValueForFormulaIdentifier']} args.provideValueForFormulaIdentifier
+ * @param {import('./types.js').DaemonCore['provide']} args.provide
  * @param {import('./types.js').DaemonCore['provideControllerForFormulaIdentifier']} args.provideControllerForFormulaIdentifier
  * @param {import('./types.js').DaemonCore['cancelValue']} args.cancelValue
  * @param {import('./types.js').DaemonCore['incarnateWorker']} args.incarnateWorker
@@ -31,7 +31,7 @@ const assertPowersName = name => {
  * @param {string} args.ownNodeIdentifier
  */
 export const makeHostMaker = ({
-  provideValueForFormulaIdentifier,
+  provide,
   provideControllerForFormulaIdentifier,
   cancelValue,
   incarnateWorker,
@@ -74,7 +74,7 @@ export const makeHostMaker = ({
     const basePetStore = /** @type {import('./types.js').PetStore} */ (
       // Behold, recursion:
       // eslint-disable-next-line no-use-before-define
-      await provideValueForFormulaIdentifier(storeFormulaIdentifier)
+      await provide(storeFormulaIdentifier)
     );
     const specialStore = makePetSitter(basePetStore, {
       ...platformNames,
@@ -97,7 +97,7 @@ export const makeHostMaker = ({
     const getEndoBootstrap = async () => {
       const endoBootstrap =
         /** @type {import('./types.js').FarEndoBootstrap} */ (
-          await provideValueForFormulaIdentifier(endoFormulaIdentifier)
+          await provide(endoFormulaIdentifier)
         );
       return endoBootstrap;
     };
@@ -135,7 +135,7 @@ export const makeHostMaker = ({
       if (workerFormulaIdentifier !== undefined) {
         return /** @type {Promise<import('./types.js').EndoWorker>} */ (
           // Behold, recursion:
-          provideValueForFormulaIdentifier(workerFormulaIdentifier)
+          provide(workerFormulaIdentifier)
         );
       }
 
@@ -545,7 +545,7 @@ export const makeHostMaker = ({
     });
     const internal = harden({ receive, respond, petStore });
 
-    await provideValueForFormulaIdentifier(mainWorkerFormulaIdentifier);
+    await provide(mainWorkerFormulaIdentifier);
 
     return harden({ external, internal });
   };