Merge pull request #138 from hyperware-ai/hf/rename

rename

Author: nick1udwig

.github/ISSUE_TEMPLATE/bug_report.md

@@ -26,7 +26,7 @@ If applicable, add screenshots to help explain your problem.
 **Desktop (please complete the following information):**
  - OS: [e.g. iOS]
  - Browser [e.g. chrome, safari]
- - Kinode version [e.g. v1.0.0]
+ - Hyperware version [e.g. v1.0.0]
  - process_lib version [e.g. v1.0.0]
 
 **Additional context**

Cargo.lock

@@ -1,11 +1,11 @@
 [package]
-name = "kinode_process_lib"
+name = "hyperware_process_lib"
 authors = ["Sybil Technologies AG"]
-version = "1.0.1"
+version = "1.0.2"
 edition = "2021"
-description = "A library for writing Kinode processes in Rust."
-homepage = "https://kinode.org"
-repository = "https://github.com/kinode-dao/process_lib"
+description = "A library for writing Hyperware processes in Rust."
+homepage = "https://hyperware.ai"
+repository = "https://github.com/hyperware-ai/process_lib"
 license = "Apache-2.0"
 
 [features]

Cargo.toml

@@ -1,14 +1,9 @@
-# `kinode_process_lib`
+# `hyperware_process_lib`
 
-Library of functions for more ergonomic [Kinode](https://github.com/kinode-dao/kinode) Rust process development.
+Library of functions for more ergonomic Hyperware Rust process development.
 
-[Documentation can be found here](https://docs.rs/kinode_process_lib).
+[Documentation can be found here](https://docs.rs/hyperware_process_lib).
 
-[Crate can be found here](https://crates.io/crates/kinode_process_lib).
+[Crate can be found here](https://crates.io/crates/hyperware_process_lib).
 
-See the [Kinode Book](https://book.kinode.org) for a guide on how to use this library to write Kinode apps in Rust.
-
-The major version of `kinode_process_lib` will always match the major version of Kinode OS.
-Since the current major version of both is 0, breaking changes can occur on minor releases.
-Once the major version reaches 1, breaking changes will only occur between major versions.
-As is, developers may have to update their version of `process_lib` as they update Kinode OS.
+See the [Hyperware Book](https://book.hyperware.ai) for a guide on how to use this library to write Hyperware apps in Rust.

README.md

@@ -1,9 +1,4 @@
-//
-// kinode.wit, copied from https://github.com/kinode-dao/kinode-wit
-// https://raw.githubusercontent.com/kinode-dao/kinode-wit/v1.0.0/kinode.wit
-//
-
-package kinode:process@1.0.0;
+package hyperware:process@1.0.0;
 
 interface standard {
 
@@ -49,7 +44,7 @@ interface standard {
         // expects-response is none, direct response to source of parent.
         // also carries forward certain aspects of parent message in kernel,
         // see documentation for formal spec and examples:
-        // https://docs.rs/kinode_process_lib/latest/kinode_process_lib/struct.Request.html
+        // https://docs.rs/hyperware_process_lib/latest/hyperware_process_lib/struct.Request.html
         inherit: bool,
         // if some, request expects a response in the given number of seconds
         expects-response: option<u64>,
@@ -226,4 +221,4 @@ world process-v1 {
     include lib;
 
     export init: func(our: string);
-}
+}

kinode-wit/kinode.wit renamed to hyperware-wit/hyperware.wit

@@ -8,7 +8,7 @@
 
 ## Docs Update
 
-[Corresponding docs PR](https://github.com/kinode-dao/kinode-book/pull/my-pr-number)
+[Corresponding docs PR](https://github.com/hyperware-ai/hyperware-book/pull/my-pr-number)
 
 ## Notes
 

pull_request_template.md

@@ -68,7 +68,7 @@ pub enum EthAction {
     },
     /// Kill a SubscribeLogs subscription of a given ID, to stop getting updates.
     UnsubscribeLogs(u64),
-    /// Raw request. Used by kinode_process_lib.
+    /// Raw request. Used by hyperware_process_lib.
     Request {
         chain_id: u64,
         method: String,

src/eth.rs

@@ -1,6 +1,6 @@
 use crate::Request;
 
-/// Add a new icon and/or widget to the Kinode homepage. Note that the process calling this
+/// Add a new icon and/or widget to the Hyperware homepage. Note that the process calling this
 /// function must have the `homepage:homepage:sys` messaging [`crate::Capability`].
 ///
 /// This should be called upon process startup to ensure that the process is added to the homepage.
@@ -29,7 +29,7 @@ pub fn add_to_homepage(label: &str, icon: Option<&str>, path: Option<&str>, widg
         .unwrap();
 }
 
-/// Remove the caller process from the Kinode homepage. Note that the process calling this function
+/// Remove the caller process from the Hyperware homepage. Note that the process calling this function
 /// must have the `homepage:homepage:sys` messaging [`crate::Capability`].
 ///
 /// This usually isn't necessary as processes are not persisted on homepage between boots.

src/homepage.rs

@@ -202,22 +202,22 @@ pub enum HttpServerAction {
     },
     /// When sent, expects a [`crate::LazyLoadBlob`] containing the WebSocket message bytes to send.
     /// Modifies the [`crate::LazyLoadBlob`] by placing into [`HttpServerAction::WebSocketExtPushData`]` with id taken from
-    /// this [`KernelMessage`]` and `kinode_message_type` set to `desired_reply_type`.
+    /// this [`KernelMessage`]` and `hyperware_message_type` set to `desired_reply_type`.
     WebSocketExtPushOutgoing {
         channel_id: u32,
         message_type: WsMessageType,
         desired_reply_type: MessageType,
     },
     /// For communicating with the ext.
-    /// Kinode's http-server sends this to the ext after receiving [`HttpServerAction::WebSocketExtPushOutgoing`].
+    /// Hyperware's http-server sends this to the ext after receiving [`HttpServerAction::WebSocketExtPushOutgoing`].
     /// Upon receiving reply with this type from ext, http-server parses, setting:
     /// * id as given,
     /// * message type as given ([`crate::Request`] or [`crate::Response`]),
     /// * body as [`HttpServerRequest::WebSocketPush`],
     /// * [`crate::LazyLoadBlob`] as given.
     WebSocketExtPushData {
         id: u64,
-        kinode_message_type: MessageType,
+        hyperware_message_type: MessageType,
         blob: Vec<u8>,
     },
     /// Sending will close a socket the process controls.
@@ -562,7 +562,7 @@ impl HttpServer {
                 })
                 .unwrap(),
             )
-            .blob(crate::kinode::process::standard::LazyLoadBlob {
+            .blob(crate::hyperware::process::standard::LazyLoadBlob {
                 mime: content_type.clone(),
                 bytes: content.clone(),
             })

src/http/server.rs

@@ -1,4 +1,4 @@
-use crate::kinode::process::standard as wit;
+use crate::hyperware::process::standard as wit;
 use crate::{Address, ProcessId};
 use serde::{Deserialize, Serialize};
 use std::collections::{HashMap, HashSet};
@@ -7,7 +7,7 @@ use std::hash::{Hash, Hasher};
 //
 // process-facing kernel types, used for process
 // management and message-passing
-// matches types in kinode.wit
+// matches types in hyperware.wit
 //
 
 pub type Context = Vec<u8>;
@@ -265,7 +265,7 @@ impl StateError {
 // package types
 //
 
-/// Represents the metadata associated with a kinode package, which is an ERC721 compatible token.
+/// Represents the metadata associated with a hyperware package, which is an ERC721 compatible token.
 /// This is deserialized from the `metadata.json` file in a package.
 /// Fields:
 /// - `name`: An optional field representing the display name of the package. This does not have to be unique, and is not used for identification purposes.
@@ -284,7 +284,7 @@ pub struct Erc721Metadata {
     pub properties: Erc721Properties,
 }
 
-/// Represents critical fields of a kinode package in an ERC721 compatible format.
+/// Represents critical fields of a hyperware package in an ERC721 compatible format.
 /// This follows the [ERC1155](https://github.com/ethereum/ercs/blob/master/ERCS/erc-1155.md#erc-1155-metadata-uri-json-schema) metadata standard.
 ///
 /// Fields:

src/kernel_types.rs

@@ -1,7 +1,7 @@
-//! Kinode process standard library for Rust compiled to Wasm
-//! Must be used in context of bindings generated by `kinode.wit`.
+//! Hyperware process standard library for Rust compiled to Wasm
+//! Must be used in context of bindings generated by `hyperware.wit`.
 //!
-//! This library provides a set of functions for interacting with the kinode
+//! This library provides a set of functions for interacting with the hyperware
 //! kernel interface, which is a WIT file. The types generated by this file
 //! are available in processes via the wit_bindgen macro, if a process needs
 //! to use them directly. However, the most convenient way to do most things
@@ -13,11 +13,11 @@
 //! for applications that want to maximize composability and introspectability.
 //! For blobs, we recommend bincode to serialize and deserialize to bytes.
 //!
-pub use crate::kinode::process::standard::*;
+pub use crate::hyperware::process::standard::*;
 use serde_json::Value;
 
 wit_bindgen::generate!({
-    path: "kinode-wit",
+    path: "hyperware-wit",
     generate_unused_types: true,
     world: "lib",
 });
@@ -155,7 +155,7 @@ macro_rules! process_println {
 ///
 /// Example:
 /// ```no_run
-/// use kinode_process_lib::{await_message, println};
+/// use hyperware_process_lib::{await_message, println};
 ///
 /// loop {
 ///     match await_message() {
@@ -185,7 +185,7 @@ pub fn await_next_message_body() -> Result<Vec<u8>, SendError> {
 }
 
 /// Spawn a new process. This function is a wrapper around the standard `spawn()` function
-/// provided in `kinode::process::standard` (which is generated by the WIT file).
+/// provided in `hyperware::process::standard` (which is generated by the WIT file).
 pub fn spawn(
     name: Option<&str>,
     wasm_path: &str,
@@ -194,7 +194,7 @@ pub fn spawn(
     grant_capabilities: Vec<(ProcessId, Json)>,
     public: bool,
 ) -> Result<ProcessId, SpawnError> {
-    crate::kinode::process::standard::spawn(
+    crate::hyperware::process::standard::spawn(
         name,
         wasm_path,
         &on_exit._to_standard().map_err(|_e| SpawnError::NameTaken)?,
@@ -209,7 +209,7 @@ pub fn spawn(
 ///
 /// Example usage:
 /// ```no_run
-/// use kinode_process_lib::make_blob;
+/// use hyperware_process_lib::make_blob;
 /// use bincode;
 /// use serde::{Serialize, Deserialize};
 ///
@@ -244,7 +244,7 @@ where
 /// Example:
 /// ```no_run
 /// use std::collections::{HashMap, HashSet};
-/// use kinode_process_lib::get_typed_blob;
+/// use hyperware_process_lib::get_typed_blob;
 /// use bincode;
 /// use serde::{Serialize, Deserialize};
 ///
@@ -280,7 +280,7 @@ where
 /// Example:
 /// ```no_run
 /// use std::collections::{HashMap, HashSet};
-/// use kinode_process_lib::get_typed_state;
+/// use hyperware_process_lib::get_typed_state;
 /// use bincode;
 /// use serde::{Serialize, Deserialize};
 ///

src/lib.rs

@@ -7,7 +7,7 @@ use std::collections::BTreeMap;
 //
 
 /// The data structure used by `net:distro:sys` and the rest of the runtime to
-/// represent node identities in the KNS (Kinode Name System).
+/// represent node identities in the KNS (Hyperware Name System).
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct Identity {
     pub name: NodeId,

src/net.rs

@@ -13,7 +13,7 @@ macro_rules! script {
         struct Component;
         impl Guest for Component {
             fn init(our: String) {
-                use kinode_process_lib::{await_message, println, Address, Message, Response};
+                use hyperware_process_lib::{await_message, println, Address, Message, Response};
                 let our: Address = our.parse().unwrap();
                 let Message::Request {
                     body,
@@ -54,13 +54,13 @@ macro_rules! script {
 ///     world: "process-v0",
 /// });
 ///
-/// kinode_process_lib::widget!("My widget", create_widget);
+/// hyperware_process_lib::widget!("My widget", create_widget);
 ///
 /// fn create_widget() -> String {
 ///     return r#"<html>
 ///         <head>
 ///             <meta name="viewport" content="width=device-width, initial-scale=1">
-///             <link rel="stylesheet" href="/kinode.css">
+///             <link rel="stylesheet" href="/hyperware.css">
 ///         </head>
 ///         <body>
 ///             <h1>Hello World!</h1>
@@ -73,7 +73,7 @@ macro_rules! widget {
         struct Component;
         impl Guest for Component {
             fn init(_our: String) {
-                use kinode_process_lib::Request;
+                use hyperware_process_lib::Request;
                 Request::to(("our", "homepage", "homepage", "sys"))
                     .body(
                         serde_json::json!({

src/scripting/mod.rs

@@ -2,7 +2,7 @@ pub use crate::{Address, ProcessId, Request};
 use serde::{Deserialize, Serialize};
 use std::hash::{Hash, Hasher};
 
-/// Address is defined in `kinode.wit`, but constructors and methods here.
+/// Address is defined in `hyperware.wit`, but constructors and methods here.
 /// An Address is a combination of a node ID (string) and a [`ProcessId`]. It is
 /// used in the [`Request`]/[`crate::Response`] pattern to indicate which process on a given node
 /// in the network to direct the message to. The formatting structure for

src/types/address.rs

@@ -4,7 +4,7 @@ pub use crate::LazyLoadBlob;
 /// A `LazyLoadBlob` is a piece of data that is only optionally loaded into a process
 /// (i.e. with `get_blob()`). `LazyLoadBlob` is useful for passing large data in a chain
 /// of [`crate::Request`]s or [`crate::Response`]s where intermediate processes in the
-/// chain don't need to access the data. In this way, Kinode saves time and compute
+/// chain don't need to access the data. In this way, Hyperware saves time and compute
 /// since the `LazyLoadBlob` is not sent back and forth across the Wasm boundary needlessly.
 impl LazyLoadBlob {
     /// Create a new `LazyLoadBlob`. Takes a mime type and a byte vector.